mirror of
https://github.com/Relintai/entity_spell_system.git
synced 2025-02-22 17:18:12 +01:00
2399 lines
70 KiB
C++
2399 lines
70 KiB
C++
#include "entity.h"
|
|
|
|
#include "../data/aura.h"
|
|
#include "../data/spell.h"
|
|
#include "../entities/auras/aura_data.h"
|
|
#include "../pipelines/spell_damage_info.h"
|
|
|
|
NodePath Entity::get_character_skeleton_path() {
|
|
return _character_skeleton_path;
|
|
}
|
|
|
|
void Entity::set_character_skeleton_path(NodePath value) {
|
|
_character_skeleton_path = value;
|
|
|
|
Node *node = get_node_or_null(_character_skeleton_path);
|
|
|
|
if (node != NULL) {
|
|
_character_skeleton = Object::cast_to<CharacterSkeleton>(node);
|
|
} else {
|
|
_character_skeleton = NULL;
|
|
}
|
|
}
|
|
|
|
CharacterSkeleton *Entity::get_character_skeleton() {
|
|
return _character_skeleton;
|
|
}
|
|
|
|
int Entity::getc_guid() {
|
|
return _c_guid;
|
|
}
|
|
void Entity::setc_guid(int value) {
|
|
_c_guid = value;
|
|
}
|
|
|
|
int Entity::gets_guid() {
|
|
return _s_guid;
|
|
}
|
|
void Entity::sets_guid(int value) {
|
|
_s_guid = value;
|
|
}
|
|
|
|
PlayerStates Entity::getc_state() {
|
|
return _c_state;
|
|
}
|
|
void Entity::setc_state(PlayerStates state) {
|
|
_c_state = state;
|
|
}
|
|
|
|
PlayerStates Entity::gets_state() {
|
|
return _s_state;
|
|
}
|
|
void Entity::sets_state(PlayerStates state) {
|
|
_s_state = state;
|
|
}
|
|
|
|
int Entity::gets_class_id() {
|
|
return _s_class_id;
|
|
}
|
|
void Entity::sets_class_id(int value) {
|
|
_s_class_id = value;
|
|
}
|
|
|
|
int Entity::getc_class_id() {
|
|
return _c_class_id;
|
|
}
|
|
void Entity::setc_class_id(int value) {
|
|
_c_class_id = value;
|
|
}
|
|
|
|
EntityEnums::EntityType Entity::gets_entity_type() {
|
|
return _s_entity_type;
|
|
}
|
|
void Entity::sets_entity_type(EntityEnums::EntityType value) {
|
|
_s_entity_type = value;
|
|
}
|
|
|
|
EntityEnums::EntityType Entity::getc_entity_type() {
|
|
return _c_entity_type;
|
|
}
|
|
void Entity::setc_entity_type(EntityEnums::EntityType value) {
|
|
_c_entity_type = value;
|
|
}
|
|
|
|
String Entity::gets_player_name() {
|
|
return _s_player_name;
|
|
}
|
|
void Entity::sets_player_name(String value) {
|
|
_s_player_name = value;
|
|
}
|
|
|
|
String Entity::getc_player_name() {
|
|
return _c_player_name;
|
|
}
|
|
void Entity::setc_player_name(String value) {
|
|
_c_player_name = value;
|
|
}
|
|
|
|
int Entity::gets_gender() {
|
|
return _s_gender;
|
|
}
|
|
void Entity::sets_gender(int value) {
|
|
_s_gender = value;
|
|
}
|
|
|
|
int Entity::getc_gender() {
|
|
return _c_gender;
|
|
}
|
|
void Entity::setc_gender(int value) {
|
|
_c_gender = value;
|
|
}
|
|
|
|
int Entity::gets_level() {
|
|
return _s_level;
|
|
}
|
|
void Entity::sets_level(int value) {
|
|
_s_level = value;
|
|
}
|
|
|
|
int Entity::getc_level() {
|
|
return _c_level;
|
|
}
|
|
void Entity::setc_level(int value) {
|
|
_c_level = value;
|
|
}
|
|
|
|
int Entity::gets_xp() {
|
|
return _s_xp;
|
|
}
|
|
void Entity::sets_xp(int value) {
|
|
_s_xp = value;
|
|
}
|
|
|
|
int Entity::getc_xp() {
|
|
return _c_xp;
|
|
}
|
|
void Entity::setc_xp(int value) {
|
|
_c_xp = value;
|
|
}
|
|
|
|
Ref<CharacterClass> Entity::getc_character_class() {
|
|
return _c_character_class;
|
|
}
|
|
|
|
void Entity::setc_character_class(Ref<CharacterClass> value) {
|
|
_c_character_class = value;
|
|
|
|
emit_signal("ccharacter_class_changed", value);
|
|
}
|
|
|
|
Ref<CharacterClass> Entity::gets_character_class() {
|
|
return _s_character_class;
|
|
}
|
|
|
|
void Entity::sets_character_class(Ref<CharacterClass> value) {
|
|
_s_character_class = value;
|
|
|
|
if (value.is_valid()) {
|
|
sinitialize_stats();
|
|
}
|
|
|
|
if (!Engine::get_singleton()->is_editor_hint())
|
|
set_process(value.is_valid());
|
|
|
|
emit_signal("scharacter_class_changed", value);
|
|
|
|
setc_character_class(value);
|
|
}
|
|
|
|
Entity *Entity::gets_spell_target() {
|
|
return _s_target;
|
|
}
|
|
|
|
void Entity::sets_spell_target(Node *p_target) {
|
|
if (!p_target) {
|
|
return;
|
|
}
|
|
|
|
Entity *e = cast_to<Entity>(p_target);
|
|
|
|
if (!e) {
|
|
return;
|
|
}
|
|
|
|
_s_target = e;
|
|
|
|
emit_signal("starget_changed", _s_target);
|
|
|
|
setc_target(p_target);
|
|
}
|
|
|
|
Entity *Entity::getc_spell_target() {
|
|
return _c_target;
|
|
}
|
|
|
|
void Entity::setc_spell_target(Node *p_target) {
|
|
if (!p_target) {
|
|
return;
|
|
}
|
|
|
|
Entity *e = cast_to<Entity>(p_target);
|
|
|
|
if (!e) {
|
|
return;
|
|
}
|
|
|
|
_c_target = e;
|
|
|
|
emit_signal("ctarget_changed", _c_target);
|
|
}
|
|
|
|
Entity::Entity() {
|
|
_s_guid = 0;
|
|
_c_guid = 0;
|
|
|
|
_s_class_id = 0;
|
|
_c_class_id = 0;
|
|
|
|
_s_type = 0;
|
|
_c_type = 0;
|
|
|
|
_s_gender = 0;
|
|
_c_gender = 0;
|
|
|
|
_s_level = 50;
|
|
_c_level = 50;
|
|
|
|
_s_xp = 0;
|
|
_c_xp = 0;
|
|
|
|
_s_send_flag = 0;
|
|
|
|
_s_player_name = "";
|
|
_c_player_name = "";
|
|
|
|
_s_state = PlayerStates::STATE_NORMAL;
|
|
_c_state = PlayerStates::STATE_NORMAL;
|
|
|
|
sIsDead = false;
|
|
cIsDead = false;
|
|
|
|
cHasGlobalCooldown = false;
|
|
sHasGlobalCooldown = false;
|
|
sRezTimer = 0;
|
|
cRezTimer = 0;
|
|
|
|
_s_casting = false;
|
|
_s_spell_id = 0;
|
|
_s_current_cast_time = 0;
|
|
_s_cast_time = 0;
|
|
_s_spell_scale = 0;
|
|
_c_casting = false;
|
|
_c_spell_id = 0;
|
|
_c_current_cast_time = 0;
|
|
_c_cast_time = 0;
|
|
_c_spell_name = "";
|
|
_s_spell_target = NULL;
|
|
_c_spell_target = NULL;
|
|
_s_spell_target_guid = 0;
|
|
_s_spell_cast_game_object_guid = 0;
|
|
|
|
_s_entity_type = EntityEnums::EntityType::ENITIY_TYPE_NONE;
|
|
_c_entity_type = EntityEnums::EntityType::ENITIY_TYPE_NONE;
|
|
|
|
_s_target = NULL;
|
|
_c_target = NULL;
|
|
|
|
/*
|
|
auras = new Vector<AuraData>();
|
|
serverAuras = new Vector<AuraData>();
|
|
|
|
c_spell_name = "";
|
|
|
|
cTalents = new Vector<PlayerTalent>();
|
|
sTalents = new Vector<PlayerTalent>();
|
|
owner = owner;*/
|
|
|
|
/*
|
|
cCraftMaterialInventory = new Vector<ItemInstance>();
|
|
sCraftMaterialInventory = new Vector<ItemInstance>();
|
|
cInventory = new Vector<ItemInstance>();
|
|
sInventory = new Vector<ItemInstance>();
|
|
INVENTORY_DEFAULT_SIZE = 21;
|
|
owner = owner;
|
|
for (int i = 0; i < 21; i += 1) {
|
|
cInventory->Add(null);
|
|
sInventory->Add(null);
|
|
}*/
|
|
|
|
for (int i = 0; i < Stat::STAT_ID_TOTAL_STATS; ++i) {
|
|
_stats[i] = Ref<Stat>(memnew(Stat(static_cast<Stat::StatId>(i))));
|
|
}
|
|
|
|
get_stat_enum(Stat::STAT_ID_HEALTH)->set_base(10000);
|
|
get_stat_enum(Stat::STAT_ID_MANA)->set_base(100);
|
|
get_stat_enum(Stat::STAT_ID_SPEED)->set_base(4.2);
|
|
get_stat_enum(Stat::STAT_ID_GLOBAL_COOLDOWN)->set_base(1.5);
|
|
get_stat_enum(Stat::STAT_ID_MELEE_CRIT)->set_base(5);
|
|
get_stat_enum(Stat::STAT_ID_MELEE_CRIT_BONUS)->set_base(50);
|
|
get_stat_enum(Stat::STAT_ID_SPELL_CRIT)->set_base(5);
|
|
get_stat_enum(Stat::STAT_ID_SPELL_CRIT_BONUS)->set_base(50);
|
|
get_stat_enum(Stat::STAT_ID_BLOCK)->set_base(10);
|
|
get_stat_enum(Stat::STAT_ID_PARRY)->set_base(15);
|
|
get_stat_enum(Stat::STAT_ID_MELEE_DAMAGE_REDUCTION)->set_base(15);
|
|
|
|
_health = Ref<Stat>(get_stat_enum(Stat::STAT_ID_HEALTH));
|
|
_mana = Ref<Stat>(get_stat_enum(Stat::STAT_ID_MANA));
|
|
_speed = Ref<Stat>(get_stat_enum(Stat::STAT_ID_SPEED));
|
|
_gcd = Ref<Stat>(get_stat_enum(Stat::STAT_ID_GLOBAL_COOLDOWN));
|
|
|
|
_melee_crit = Ref<Stat>(get_stat_enum(Stat::STAT_ID_MELEE_CRIT));
|
|
_melee_crit_bonus = Ref<Stat>(get_stat_enum(Stat::STAT_ID_MELEE_CRIT_BONUS));
|
|
_spell_crit = Ref<Stat>(get_stat_enum(Stat::STAT_ID_SPELL_CRIT));
|
|
_spell_crit_bonus = Ref<Stat>(get_stat_enum(Stat::STAT_ID_SPELL_CRIT_BONUS));
|
|
|
|
_block = Ref<Stat>(get_stat_enum(Stat::STAT_ID_BLOCK));
|
|
_parry = Ref<Stat>(get_stat_enum(Stat::STAT_ID_PARRY));
|
|
_damage_reduction = Ref<Stat>(get_stat_enum(Stat::STAT_ID_DAMAGE_REDUCTION));
|
|
_melee_damage_reduction = Ref<Stat>(get_stat_enum(Stat::STAT_ID_MELEE_DAMAGE_REDUCTION));
|
|
_spell_damage_reduction = Ref<Stat>(get_stat_enum(Stat::STAT_ID_SPELL_DAMAGE_REDUCTION));
|
|
_damage_taken = Ref<Stat>(get_stat_enum(Stat::STAT_ID_DAMAGE_TAKEN));
|
|
_melee_damage = Ref<Stat>(get_stat_enum(Stat::STAT_ID_MELEE_DAMAGE));
|
|
_spell_damage = Ref<Stat>(get_stat_enum(Stat::STAT_ID_SPELL_DAMAGE));
|
|
|
|
_s_auras = memnew(Vector<Ref<AuraData> >());
|
|
_c_auras = memnew(Vector<Ref<AuraData> >());
|
|
}
|
|
|
|
Entity::~Entity() {
|
|
_s_auras->clear();
|
|
_c_auras->clear();
|
|
|
|
memdelete(_s_auras);
|
|
memdelete(_c_auras);
|
|
}
|
|
|
|
void Entity::initialize(Ref<EntityCreateInfo> info) {
|
|
ERR_FAIL_COND(!info.is_valid());
|
|
|
|
_s_player_name = info->get_player_name();
|
|
_c_player_name = info->get_player_name();
|
|
|
|
sets_entity_type(info->get_entity_type());
|
|
setc_entity_type(info->get_entity_type());
|
|
|
|
sets_level(info->get_level());
|
|
setc_level(info->get_level());
|
|
|
|
sets_xp(info->get_xp());
|
|
setc_xp(info->get_xp());
|
|
|
|
sets_character_class(info->get_character_class());
|
|
//setc_character_class(info->get_character_class());
|
|
/*
|
|
if (gets_character_class() != NULL) {
|
|
Ref<StatData> sd = gets_character_class()->get_stat_data();
|
|
|
|
for (int i = 0; i < Stat::STAT_ID_TOTAL_STATS; ++i) {
|
|
Ref<StatDataEntry> entry = sd->get_stat_data_int(i);
|
|
Ref<Stat> stat = get_stat_int(i);
|
|
|
|
entry->get_stats_for_stat(stat);
|
|
|
|
if (entry->has_dependency()) {
|
|
Ref<Stat> other = get_stat_enum(entry->get_depends_on());
|
|
|
|
stat->set_dependency(other, entry->get_dependdency_curve());
|
|
}
|
|
}
|
|
}*/
|
|
}
|
|
|
|
void Entity::sinitialize_stats() {
|
|
//gets_character_class()->get_stat_data()->get_stats_for_stat(_health);
|
|
//Ref<StatDataEntry> e = gets_character_class()->get_stat_data()->get_stat_data_enum(Stat::STAT_ID_HEALTH);
|
|
|
|
gets_character_class()->get_stat_data()->get_stat_for_stat(get_health());
|
|
gets_character_class()->get_stat_data()->get_stat_for_stat(get_mana());
|
|
gets_character_class()->get_stat_data()->get_stat_for_stat(get_speed());
|
|
gets_character_class()->get_stat_data()->get_stat_for_stat(get_gcd());
|
|
gets_character_class()->get_stat_data()->get_stat_for_stat(get_melee_crit());
|
|
gets_character_class()->get_stat_data()->get_stat_for_stat(get_melee_crit_bonus());
|
|
gets_character_class()->get_stat_data()->get_stat_for_stat(get_spell_crit());
|
|
gets_character_class()->get_stat_data()->get_stat_for_stat(get_spell_crit_bonus());
|
|
gets_character_class()->get_stat_data()->get_stat_for_stat(get_block());
|
|
gets_character_class()->get_stat_data()->get_stat_for_stat(get_parry());
|
|
gets_character_class()->get_stat_data()->get_stat_for_stat(get_melee_damage_reduction());
|
|
gets_character_class()->get_stat_data()->get_stat_for_stat(get_spell_damage_reduction());
|
|
gets_character_class()->get_stat_data()->get_stat_for_stat(get_damage_taken());
|
|
gets_character_class()->get_stat_data()->get_stat_for_stat(get_melee_damage());
|
|
gets_character_class()->get_stat_data()->get_stat_for_stat(get_spell_damage());
|
|
}
|
|
|
|
////// Stat System //////
|
|
|
|
bool Entity::gets_is_dead() {
|
|
return sIsDead;
|
|
}
|
|
|
|
bool Entity::getc_is_dead() {
|
|
return sIsDead;
|
|
}
|
|
|
|
bool Entity::getc_has_global_cooldown() {
|
|
return cHasGlobalCooldown;
|
|
}
|
|
|
|
bool Entity::gets_has_global_cooldown() {
|
|
return sHasGlobalCooldown;
|
|
}
|
|
|
|
Ref<Stat> Entity::get_stat_int(int index) {
|
|
return _stats[index];
|
|
}
|
|
|
|
void Entity::set_stat_int(int index, Ref<Stat> entry) {
|
|
_stats[index] = Ref<Stat>(entry);
|
|
}
|
|
|
|
Ref<Stat> Entity::get_stat_enum(Stat::StatId stat_id) {
|
|
//ERR_FAIL_COND_V(stat_id == Stat::STAT_ID_NONE);
|
|
|
|
if (stat_id == Stat::STAT_ID_NONE) {
|
|
print_error("Add fail cond here, stat has STAT_ID_NONE!");
|
|
return _stats[0];
|
|
}
|
|
|
|
return _stats[stat_id];
|
|
}
|
|
|
|
void Entity::set_stat_enum(Stat::StatId stat_id, Ref<Stat> entry) {
|
|
ERR_FAIL_COND(!entry.is_valid());
|
|
|
|
//ERR_FAIL_COND(stat_id == Stat::STAT_ID_NONE);
|
|
|
|
if (stat_id == Stat::STAT_ID_NONE) {
|
|
print_error("Add fail cond here, stat has STAT_ID_NONE!");
|
|
_stats[0] = Ref<Stat>(entry);
|
|
return;
|
|
}
|
|
|
|
_stats[stat_id] = Ref<Stat>(entry);
|
|
}
|
|
|
|
void Entity::stake_damage(Ref<SpellDamageInfo> data) {
|
|
ERR_FAIL_COND(!data.is_valid());
|
|
|
|
//serverside
|
|
|
|
if (gets_is_dead()) {
|
|
return;
|
|
}
|
|
|
|
//send it through the passive damage reductions pipeline
|
|
sapply_passives_damage_receive(data);
|
|
//send it through the onbeforehit handler
|
|
son_before_damage(data);
|
|
//send it throug the onhit pipeliine
|
|
son_hit(data);
|
|
son_damage_receive(data);
|
|
|
|
int h = get_health()->gets_current() - data->get_damage();
|
|
|
|
if (h < 0) {
|
|
h = 0;
|
|
}
|
|
|
|
get_health()->sets_current(h);
|
|
|
|
//send an event to client
|
|
creceive_damage_taken(data);
|
|
|
|
//signal
|
|
emit_signal("son_damage_taken", this, data);
|
|
|
|
if (get_health()->gets_current() <= 0) {
|
|
die();
|
|
}
|
|
}
|
|
|
|
void Entity::son_damage_dealt(Ref<SpellDamageInfo> data) {
|
|
ERR_FAIL_COND(!data.is_valid());
|
|
|
|
//serverside
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_damage_dealt(data);
|
|
}
|
|
}
|
|
|
|
void Entity::sdeal_damage_to(Ref<SpellDamageInfo> data) {
|
|
ERR_FAIL_COND(!data.is_valid());
|
|
|
|
//serverside
|
|
|
|
if (gets_is_dead()) {
|
|
return;
|
|
}
|
|
|
|
sapply_passives_damage_deal(data);
|
|
data->get_receiver()->stake_damage(data);
|
|
son_damage_dealt(data);
|
|
}
|
|
|
|
void Entity::take_heal(int heal, bool crit, Entity *dealer) {
|
|
/*
|
|
if (sIsDead) {
|
|
return;
|
|
}
|
|
Stat *expr_0F = SHealth;
|
|
expr_0F->Current += (float)(heal);
|
|
if (SHealth->Current > SHealth->Max) {
|
|
SHealth->Current = SHealth->Max;
|
|
}
|
|
if (owner->isServer) {
|
|
SendHealTakenMessage(heal, crit, dealer);
|
|
}*/
|
|
}
|
|
|
|
void Entity::die() {
|
|
/*
|
|
if (!CxNet::IsServer) {
|
|
return;
|
|
}
|
|
sRezTimer = (float)5;
|
|
sIsDead = true;
|
|
if (SOnDeath != null) {
|
|
DELEGATE_INVOKE(SOnDeath);
|
|
}
|
|
SendDieMessage();*/
|
|
}
|
|
|
|
void Entity::resurrect() {
|
|
/*
|
|
if (!CxNet::IsServer) {
|
|
return;
|
|
}
|
|
sIsDead = false;
|
|
SHealth->SetToMax();
|
|
SHealth->Dirty = false;
|
|
if (SOnResurrect != null) {
|
|
DELEGATE_INVOKE(SOnResurrect);
|
|
}
|
|
GameObject *graveyardSpawnPoint = GameObject::FindGameObjectWithTag(new String("StartPosition"))->GetComponent<SpawnPointManager>()->GetGraveyardSpawnPoint();
|
|
owner->transform->position = graveyardSpawnPoint->transform->position;
|
|
owner->transform->rotation = graveyardSpawnPoint->transform->rotation;
|
|
SendResurrectMessage();*/
|
|
}
|
|
|
|
void Entity::creceive_resurrect() {
|
|
/*
|
|
if (OnResurrect != null) {
|
|
DELEGATE_INVOKE(OnResurrect);
|
|
}
|
|
cIsDead = false;
|
|
CHealth->SetToMax();
|
|
CHealth->Dirty = false;*/
|
|
}
|
|
|
|
void Entity::creceive_damage_taken(Ref<SpellDamageInfo> data) {
|
|
ERR_FAIL_COND(!data.is_valid());
|
|
|
|
//the current c health should probably be set here.
|
|
emit_signal("con_damage_taken", this, data);
|
|
}
|
|
|
|
void Entity::creceiveon_damage_dealt(Ref<SpellDamageInfo> data) {
|
|
ERR_FAIL_COND(!data.is_valid());
|
|
|
|
//the current c health should probably be set here.
|
|
emit_signal("con_damage_dealt", this, data);
|
|
}
|
|
|
|
void Entity::creceive_heal_taken(int heal, bool crit, Entity *dealer) {
|
|
/*
|
|
if (CHealth->Current > CHealth->Max) {
|
|
CHealth->Current = CHealth->Max;
|
|
}
|
|
if (COnHealTaken != null) {
|
|
DELEGATE_INVOKE(COnHealTaken, heal, crit, owner, dealer);
|
|
}*/
|
|
}
|
|
|
|
void Entity::creceive_died() {
|
|
/*
|
|
cIsDead = true;
|
|
cRezTimer = (float)5;
|
|
if (OnDeath != null) {
|
|
DELEGATE_INVOKE(OnDeath);
|
|
}
|
|
for (int i = 0; i < eventHandlers->Count; i += 1) {
|
|
eventHandlers->GetData(i)->OnDied(owner->transform->gameObject);
|
|
}*/
|
|
}
|
|
|
|
void Entity::creceive_mana_changed(int amount) {
|
|
/*
|
|
Stat *expr_06 = CMana;
|
|
expr_06->Current -= (float)(amount);
|
|
for (int i = 0; i < eventHandlers->Count; i += 1) {
|
|
eventHandlers->GetData(i)->OnManaUse(owner->transform->gameObject, amount, (int)(CMana->Current));
|
|
}*/
|
|
}
|
|
|
|
void Entity::son_before_aura_applied(Ref<AuraData> data) {
|
|
ERR_FAIL_COND(!data.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_before_aura_applied(data);
|
|
}
|
|
}
|
|
|
|
void Entity::son_after_aura_applied(Ref<AuraData> data) {
|
|
ERR_FAIL_COND(!data.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
if (ad == data) {
|
|
continue;
|
|
}
|
|
|
|
ad->get_aura()->son_after_aura_applied(data);
|
|
}
|
|
}
|
|
|
|
void Entity::trigger_global_cooldown() {
|
|
/*
|
|
if (!owner->isServer) {
|
|
return;
|
|
}
|
|
sHasGlobalCooldown = true;
|
|
if (BSSettings::Getinstance()->AnimStopEnabled) {
|
|
SGCD->ModCurrent = SGCD->ModMax - BSSettings::Getinstance()->GetBSTestAnimStopDataForClass(owner->PlayerData->ClassId)->GCDReduce;
|
|
} else {
|
|
SGCD->ModCurrent = SGCD->ModMax;
|
|
}
|
|
SGCD->Dirty = false;
|
|
if (SOnStatChanged != null) {
|
|
DELEGATE_INVOKE(SOnStatChanged, 3, SGCD);
|
|
}
|
|
SendTriggerGCDMessage();*/
|
|
}
|
|
|
|
void Entity::creceive_trigger_global_cooldown() {
|
|
/*
|
|
if (!owner->isClient) {
|
|
return;
|
|
}
|
|
CGCD->ModCurrent = CGCD->ModMax;
|
|
CGCD->Dirty = false;
|
|
cHasGlobalCooldown = true;
|
|
if (OnStatChanged != null) {
|
|
DELEGATE_INVOKE(OnStatChanged, 3, CGCD);
|
|
}*/
|
|
}
|
|
|
|
//// Spell System ////
|
|
|
|
void Entity::scast_spell(int spell_id) {
|
|
Ref<CharacterClass> cc = gets_character_class();
|
|
|
|
if (cc == NULL)
|
|
return;
|
|
|
|
cc->start_casting(spell_id, this, 1);
|
|
}
|
|
|
|
void Entity::crequest_spell_cast(int spell_id) {
|
|
scast_spell(spell_id);
|
|
}
|
|
|
|
void Entity::update_auras(float delta) {
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->supdate(ad, delta);
|
|
}
|
|
}
|
|
|
|
void Entity::son_before_cast(Ref<SpellCastInfo> info) {
|
|
ERR_FAIL_COND(!info.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_before_cast(info);
|
|
}
|
|
}
|
|
|
|
void Entity::son_before_cast_target(Ref<SpellCastInfo> info) {
|
|
ERR_FAIL_COND(!info.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_before_cast_target(info);
|
|
}
|
|
}
|
|
|
|
void Entity::son_hit(Ref<SpellDamageInfo> data) {
|
|
ERR_FAIL_COND(!data.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_hit(data);
|
|
}
|
|
}
|
|
|
|
void Entity::son_before_damage(Ref<SpellDamageInfo> data) {
|
|
ERR_FAIL_COND(!data.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_before_damage(data);
|
|
}
|
|
}
|
|
|
|
void Entity::son_damage_receive(Ref<SpellDamageInfo> data) {
|
|
ERR_FAIL_COND(!data.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_damage_receive(data);
|
|
}
|
|
}
|
|
|
|
void Entity::son_dealt_damage(Ref<SpellDamageInfo> data) {
|
|
ERR_FAIL_COND(!data.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_damage_dealt(data);
|
|
}
|
|
}
|
|
|
|
void Entity::sapply_passives_damage_receive(Ref<SpellDamageInfo> data) {
|
|
ERR_FAIL_COND(!data.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->sapply_passives_damage_receive(data);
|
|
}
|
|
}
|
|
|
|
void Entity::sapply_passives_damage_deal(Ref<SpellDamageInfo> data) {
|
|
ERR_FAIL_COND(!data.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->sapply_passives_damage_deal(data);
|
|
}
|
|
}
|
|
|
|
void Entity::son_cast_finished(Ref<SpellCastInfo> info) {
|
|
ERR_FAIL_COND(!info.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_cast_finished(info);
|
|
}
|
|
}
|
|
|
|
void Entity::son_cast_started(Ref<SpellCastInfo> info) {
|
|
ERR_FAIL_COND(!info.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_cast_started(info);
|
|
}
|
|
}
|
|
|
|
void Entity::son_cast_failed(Ref<SpellCastInfo> info) {
|
|
ERR_FAIL_COND(!info.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_cast_failed(info);
|
|
}
|
|
}
|
|
|
|
void Entity::son_cast_finished_target(Ref<SpellCastInfo> info) {
|
|
ERR_FAIL_COND(!info.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_cast_finished_target(info);
|
|
}
|
|
}
|
|
|
|
void Entity::sadd_aura(Ref<AuraData> aura) {
|
|
ERR_FAIL_COND(!aura.is_valid());
|
|
|
|
son_before_aura_applied(aura);
|
|
|
|
aura->set_owner(this);
|
|
|
|
_s_auras->push_back(aura);
|
|
|
|
son_after_aura_applied(aura);
|
|
|
|
emit_signal("saura_added", aura);
|
|
|
|
cadd_aura(aura);
|
|
}
|
|
|
|
void Entity::sremove_aura(Ref<AuraData> aura) {
|
|
ERR_FAIL_COND(!aura.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); i++) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
if (ad == aura) {
|
|
ad->get_aura()->son_remove(ad);
|
|
|
|
_s_auras->remove(i);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
emit_signal("saura_removed", aura);
|
|
|
|
cremove_aura(aura);
|
|
}
|
|
|
|
|
|
void Entity::sremove_aura_expired(Ref<AuraData> aura) {
|
|
ERR_FAIL_COND(!aura.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); i++) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
if (ad == aura) {
|
|
ad->get_aura()->son_remove(ad);
|
|
|
|
_s_auras->remove(i);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
emit_signal("saura_removed_expired", aura);
|
|
|
|
cremove_aura(aura);
|
|
}
|
|
|
|
void Entity::sremove_aura_dispelled(Ref<AuraData> aura) {
|
|
ERR_FAIL_COND(!aura.is_valid());
|
|
|
|
for (int i = 0; i < _s_auras->size(); i++) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
if (ad == aura) {
|
|
ad->get_aura()->son_remove(ad);
|
|
|
|
_s_auras->remove(i);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
emit_signal("saura_removed_dispelled", aura);
|
|
|
|
cremove_aura(aura);
|
|
}
|
|
|
|
void Entity::cadd_aura(Ref<AuraData> data) {
|
|
ERR_FAIL_COND(!data.is_valid());
|
|
|
|
_c_auras->push_back(data);
|
|
emit_signal("caura_added", data);
|
|
}
|
|
|
|
void Entity::cremove_aura(Ref<AuraData> aura) {
|
|
ERR_FAIL_COND(!aura.is_valid());
|
|
|
|
for (int i = 0; i < _c_auras->size(); i++) {
|
|
if (_c_auras->get(i) == aura) {
|
|
_c_auras->remove(i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
emit_signal("caura_removed", aura);
|
|
}
|
|
|
|
void Entity::cremove_aura_dispelled(Ref<AuraData> aura) {
|
|
ERR_FAIL_COND(!aura.is_valid());
|
|
|
|
for (int i = 0; i < _c_auras->size(); i++) {
|
|
if (_c_auras->get(i) == aura) {
|
|
_c_auras->remove(i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
emit_signal("caura_removed_dispelled", aura);
|
|
}
|
|
|
|
void Entity::cremove_aura_expired(Ref<AuraData> aura) {
|
|
ERR_FAIL_COND(!aura.is_valid());
|
|
|
|
for (int i = 0; i < _c_auras->size(); i++) {
|
|
if (_c_auras->get(i) == aura) {
|
|
_c_auras->remove(i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
emit_signal("caura_removed_expired", aura);
|
|
}
|
|
|
|
int Entity::sget_aura_count() {
|
|
return _s_auras->size();
|
|
}
|
|
|
|
Ref<Aura> Entity::sget_aura(int index) {
|
|
ERR_FAIL_INDEX_V(index, _s_auras->size(), Ref<Aura>(NULL));
|
|
|
|
return Ref<Aura>(_s_auras->get(index));
|
|
}
|
|
|
|
int Entity::cget_aura_count() {
|
|
return _s_auras->size();
|
|
}
|
|
|
|
Ref<Aura> Entity::cget_aura(int index) {
|
|
ERR_FAIL_INDEX_V(index, _c_auras->size(), Ref<Aura>(NULL));
|
|
|
|
return Ref<Aura>(_c_auras->get(index));
|
|
}
|
|
|
|
void Entity::moved() {
|
|
|
|
}
|
|
|
|
void Entity::con_cast_failed(Ref<SpellCastInfo> info) {
|
|
}
|
|
|
|
void Entity::con_cast_started(Ref<SpellCastInfo> info) {
|
|
}
|
|
|
|
void Entity::con_cast_state_changed(Ref<SpellCastInfo> info) {
|
|
}
|
|
|
|
void Entity::con_cast_finished(Ref<SpellCastInfo> info) {
|
|
}
|
|
|
|
void Entity::con_spell_cast_success(Ref<SpellCastInfo> info) {
|
|
}
|
|
|
|
void Entity::setup_on_player_moves(Entity *bopmccc, Vector<int> *sspells) {
|
|
}
|
|
|
|
//// Casting System ////
|
|
|
|
void Entity::sstart_casting(Ref<SpellCastInfo> info) {
|
|
_s_spell_cast_info = Ref<SpellCastInfo>(info);
|
|
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_before_cast(info);
|
|
}
|
|
|
|
_s_spell_cast_info->set_is_casting(true);
|
|
|
|
emit_signal("scast_started", info);
|
|
|
|
cstart_casting(info);
|
|
}
|
|
|
|
void Entity::sfail_cast() {
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_before_cast(_s_spell_cast_info);
|
|
}
|
|
|
|
emit_signal("scast_failed", _s_spell_cast_info);
|
|
}
|
|
|
|
void Entity::sdelay_cast() {
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_before_cast(_s_spell_cast_info);
|
|
}
|
|
|
|
emit_signal("scast_delayed", _s_spell_cast_info);
|
|
}
|
|
|
|
void Entity::sfinish_cast() {
|
|
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_cast_finished(_s_spell_cast_info);
|
|
}
|
|
|
|
_s_spell_cast_info->get_spell()->sfinish_cast(_s_spell_cast_info);
|
|
|
|
emit_signal("scast_finished", _s_spell_cast_info);
|
|
|
|
_s_spell_cast_info = Ref<SpellCastInfo>(NULL);
|
|
|
|
cfinish_cast();
|
|
}
|
|
|
|
void Entity::sinterrupt_cast() {
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
ad->get_aura()->son_before_cast(_s_spell_cast_info);
|
|
}
|
|
|
|
emit_signal("scast_interrupted", _s_spell_cast_info);
|
|
}
|
|
|
|
void Entity::cstart_casting(Ref<SpellCastInfo> info) {
|
|
_c_spell_cast_info = Ref<SpellCastInfo>(info);
|
|
|
|
emit_signal("ccast_started", _c_spell_cast_info);
|
|
}
|
|
|
|
void Entity::cfail_cast() {
|
|
emit_signal("ccast_failed", _c_spell_cast_info);
|
|
|
|
_c_spell_cast_info = Ref<SpellCastInfo>(NULL);
|
|
}
|
|
|
|
void Entity::cdelay_cast() {
|
|
|
|
emit_signal("ccast_delayed", _c_spell_cast_info);
|
|
}
|
|
|
|
void Entity::cfinish_cast() {
|
|
emit_signal("ccast_finished", _c_spell_cast_info);
|
|
_c_spell_cast_info = Ref<SpellCastInfo>(NULL);
|
|
}
|
|
|
|
void Entity::cinterrupt_cast() {
|
|
emit_signal("ccast_interrupted", _c_spell_cast_info);
|
|
_c_spell_cast_info = Ref<SpellCastInfo>(NULL);
|
|
}
|
|
|
|
//void Entity::sstart_casting(int PspellId, float PcastTime, float scale) {
|
|
/*
|
|
Spell *spell = Spells::Instance->GetData(PspellId);
|
|
StartCasting(spell, PspellId, PcastTime, scale);
|
|
*/
|
|
//}
|
|
|
|
//void Entity::sstart_casting(Spell *spell, int PspellId, float PcastTime, float spellScale) {
|
|
/*
|
|
animReduction = (float)0;
|
|
if (BSSettings::Getinstance()->AnimStopEnabled) {
|
|
animReduction = BSSettings::Getinstance()->GetBSTestAnimStopDataForClass(owner->PlayerData->ClassId)->Value;
|
|
PcastTime -= animReduction;
|
|
}
|
|
setSSpellId(PspellId);
|
|
setSCastTime(PcastTime);
|
|
setSSpellScale(spellScale);
|
|
setSCasting(true);
|
|
setSCurrentCastTime((float)0);
|
|
setCSpellId(PspellId);
|
|
setCSpellName(spell->SpellName);
|
|
setCCastTime(PcastTime);
|
|
setCCasting(true);
|
|
setCCurrentCastTime((float)0);
|
|
if (CxNet::IsServer) {
|
|
SSendStartCasting(getSSpellId(), PcastTime);
|
|
}*/
|
|
//}
|
|
|
|
//void Entity::sstart_casting(int PspellId, String PspellName, float PcastTime, float spellScale) {
|
|
/*
|
|
animReduction = (float)0;
|
|
if (BSSettings::Getinstance()->AnimStopEnabled) {
|
|
animReduction = BSSettings::Getinstance()->GetBSTestAnimStopDataForClass(owner->PlayerData->ClassId)->Value;
|
|
PcastTime -= animReduction;
|
|
}
|
|
setSSpellId(PspellId);
|
|
setSCastTime(PcastTime);
|
|
setSSpellScale(spellScale);
|
|
setSCasting(true);
|
|
setSCurrentCastTime((float)0);
|
|
setCSpellId(PspellId);
|
|
setCSpellName(PspellName);
|
|
setCCastTime(PcastTime);
|
|
setCCasting(true);
|
|
setCCurrentCastTime((float)0);
|
|
if (CxNet::IsServer) {
|
|
SSendStartCasting(getSSpellId(), PcastTime);
|
|
}*/
|
|
//}
|
|
|
|
Ref<SpellCastInfo> Entity::gets_spell_cast_info() {
|
|
return Ref<SpellCastInfo>(_s_spell_cast_info);
|
|
}
|
|
|
|
void Entity::sets_spell_cast_info(Ref<SpellCastInfo> info) {
|
|
_s_spell_cast_info = Ref<SpellCastInfo>(info);
|
|
}
|
|
|
|
Ref<SpellCastInfo> Entity::getc_spell_cast_info() {
|
|
return Ref<SpellCastInfo>(_c_spell_cast_info);
|
|
}
|
|
|
|
void Entity::setc_spell_cast_info(Ref<SpellCastInfo> info) {
|
|
_c_spell_cast_info = Ref<SpellCastInfo>(info);
|
|
}
|
|
|
|
void Entity::son_death() {
|
|
}
|
|
|
|
void Entity::sremove_auras_with_group(int aura_group) {
|
|
for (int i = 0; i < _s_auras->size(); ++i) {
|
|
Ref<AuraData> ad = _s_auras->get(i);
|
|
|
|
if (ad->get_aura()->get_aura_group() == aura_group) {
|
|
|
|
cremove_aura(ad);
|
|
|
|
_s_auras->remove(i);
|
|
|
|
emit_signal("saura_removed", ad);
|
|
|
|
cremove_aura(ad);
|
|
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
|
|
Entity *Entity::gets_target() {
|
|
return _s_target;
|
|
}
|
|
|
|
void Entity::sets_target(Node *p_target) {
|
|
if (p_target == NULL) {
|
|
_s_target = NULL;
|
|
emit_signal("starget_changed", _s_target);
|
|
setc_target(p_target);
|
|
return;
|
|
}
|
|
|
|
Entity *e = cast_to<Entity>(p_target);
|
|
|
|
if (!e) {
|
|
return;
|
|
}
|
|
|
|
_s_target = e;
|
|
|
|
emit_signal("starget_changed", _s_target);
|
|
|
|
setc_target(p_target);
|
|
}
|
|
|
|
Entity *Entity::getc_target() {
|
|
return _c_target;
|
|
}
|
|
|
|
void Entity::setc_target(Node *p_target) {
|
|
if (p_target == NULL) {
|
|
_c_target = NULL;
|
|
|
|
emit_signal("ctarget_changed", _c_target);
|
|
|
|
return;
|
|
}
|
|
|
|
Entity *e = cast_to<Entity>(p_target);
|
|
|
|
if (!e) {
|
|
return;
|
|
}
|
|
|
|
_c_target = e;
|
|
|
|
emit_signal("ctarget_changed", _c_target);
|
|
}
|
|
|
|
//// TalentCOmponent ////
|
|
|
|
void Entity::csend_request_rank_increase(int talentID) {
|
|
/*
|
|
if (CxNet::IsServer) {
|
|
CSendRequestRankIncreaseMsg cSendRequestRankIncreaseMsg = CSendRequestRankIncreaseMsg();
|
|
cSendRequestRankIncreaseMsg.Guid = owner->PlayerData->GUID;
|
|
cSendRequestRankIncreaseMsg.TalentId = talentID;
|
|
cSendRequestRankIncreaseMsg.Serialize(CxNet::NetBuffer);
|
|
CxNet::SendBufferToAllClients(0);
|
|
}*/
|
|
}
|
|
|
|
void Entity::csend_request_rank_decrease(int talentID) {
|
|
/*
|
|
if (CxNet::IsServer) {
|
|
CSendRequestRankDecreaseMsg cSendRequestRankDecreaseMsg = CSendRequestRankDecreaseMsg();
|
|
cSendRequestRankDecreaseMsg.Guid = owner->PlayerData->GUID;
|
|
cSendRequestRankDecreaseMsg.TalentId = talentID;
|
|
cSendRequestRankDecreaseMsg.Serialize(CxNet::NetBuffer);
|
|
CxNet::SendBufferToAllClients(0);
|
|
}*/
|
|
}
|
|
|
|
void Entity::ssend_rank(int talentID, int rank) {
|
|
/*
|
|
if (CxNet::IsServer) {
|
|
SSendRankValueMsg sSendRankValueMsg = SSendRankValueMsg();
|
|
sSendRankValueMsg.Guid = owner->PlayerData->GUID;
|
|
sSendRankValueMsg.TalentId = talentID;
|
|
sSendRankValueMsg.Rank = rank;
|
|
sSendRankValueMsg.Serialize(CxNet::NetBuffer);
|
|
CxNet::SendBufferToAllClients(0);
|
|
}*/
|
|
}
|
|
|
|
void Entity::sreceive_rank_increase(int talentID) {
|
|
/*
|
|
PlayerTalent *playerTalent = SGetTalent(talentID, true);
|
|
if (owner->PlayerData->Character == null) {
|
|
return;
|
|
}
|
|
Talent *talent = Talents::Instance->GetData(talentID);
|
|
if (talent == null) {
|
|
return;
|
|
}
|
|
if (talent->MaxRank >= playerTalent->getRank()) {
|
|
PlayerTalent *expr_47 = playerTalent;
|
|
int rank = expr_47->getRank();
|
|
expr_47->setRank(rank + 1);
|
|
SSendRank(talentID, playerTalent->getRank());
|
|
}*/
|
|
}
|
|
|
|
void Entity::sreceive_rank_decrease(int talentID) {
|
|
/*
|
|
PlayerTalent *playerTalent = SGetTalent(talentID, false);
|
|
if (playerTalent == null) {
|
|
return;
|
|
}
|
|
if (playerTalent->getRank() > 0) {
|
|
PlayerTalent *expr_17 = playerTalent;
|
|
int rank = expr_17->getRank();
|
|
expr_17->setRank(rank - 1);
|
|
SSendRank(talentID, playerTalent->getRank());
|
|
}*/
|
|
}
|
|
|
|
void Entity::creceive_rank(int talentID, int rank) {
|
|
/*
|
|
PlayerTalent *playerTalent = CGetTalent(talentID, true);
|
|
if (owner->PlayerData->Character == null) {
|
|
return;
|
|
}
|
|
Talent *talent = Talents::Instance->GetData(talentID);
|
|
if (talent == null) {
|
|
return;
|
|
}
|
|
if (talent->MaxRank >= playerTalent->getRank()) {
|
|
PlayerTalent *expr_47 = playerTalent;
|
|
int rank2 = expr_47->getRank();
|
|
expr_47->setRank(rank2 + 1);
|
|
if (OnCTalenChangedAction != null) {
|
|
DELEGATE_INVOKE(OnCTalenChangedAction);
|
|
}
|
|
}*/
|
|
}
|
|
|
|
PlayerTalent *Entity::sget_talent(int id, bool create) {
|
|
/*
|
|
for (int i = 0; i < sTalents->Count; i += 1) {
|
|
if (sTalents->GetData(i)->TalentID == id) {
|
|
return sTalents->GetData(i);
|
|
}
|
|
}
|
|
if (create) {
|
|
PlayerTalent *playerTalent = new PlayerTalent(id);
|
|
sTalents->Add(playerTalent);
|
|
return playerTalent;
|
|
}
|
|
return null;*/
|
|
|
|
return NULL;
|
|
}
|
|
|
|
PlayerTalent *Entity::cget_talent(int id, bool create) {
|
|
/*
|
|
for (int i = 0; i < cTalents->Count; i += 1) {
|
|
if (cTalents->GetData(i)->TalentID == id) {
|
|
return cTalents->GetData(i);
|
|
}
|
|
}
|
|
if (create) {
|
|
PlayerTalent *playerTalent = new PlayerTalent(id);
|
|
cTalents->Add(playerTalent);
|
|
return playerTalent;
|
|
}
|
|
return null;*/
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//// PlayerSpellDataComponent ////
|
|
|
|
/*
|
|
Vector<PlayerSpellData> *Entity::getSSpellData() {
|
|
return sSpellData;
|
|
}
|
|
|
|
Vector<PlayerSpellData> *Entity::getCSpellData() {
|
|
return cSpellData;
|
|
}
|
|
Dictionary_T<int, PlayerLocalSpellData> *Entity::getLocalSpellData() {
|
|
return localSpellData;
|
|
}
|
|
|
|
bool Entity::getSend() {
|
|
return send;
|
|
}
|
|
|
|
void Entity::setSend(bool value) {
|
|
send = value;
|
|
}*/
|
|
|
|
//void Entity::AddSSpellData(PlayerSpellData *psd) {
|
|
/*
|
|
sSpellData->Add(psd);
|
|
if (owner->isServer && is_inst_of<PlayerSpellCooldownData *>(psd)) {
|
|
PlayerSpellCooldownData *playerSpellCooldownData = as_cast<PlayerSpellCooldownData *>(psd);
|
|
SSendAddCPlayerSpellCooldownData(playerSpellCooldownData->SpellId, playerSpellCooldownData->getCooldown(), playerSpellCooldownData->getRemainingCooldown());
|
|
}*/
|
|
//}
|
|
|
|
//void Entity::AddCSpellData(PlayerSpellData *psd) {
|
|
/*
|
|
cSpellData->Add(psd);
|
|
if (COnSpellDataAdded != null) {
|
|
DELEGATE_INVOKE(COnSpellDataAdded, psd);
|
|
}*/
|
|
//}
|
|
|
|
//void Entity::RemoveSSpellData(PlayerSpellData *psd) {
|
|
/*
|
|
for (int i = 0; i < sSpellData->Count; i += 1) {
|
|
if (*(sSpellData->GetData(i)) == *psd) {
|
|
sSpellData->RemoveAt(i);
|
|
break;
|
|
}
|
|
}
|
|
if (owner->isServer && is_inst_of<PlayerSpellCooldownData *>(psd)) {
|
|
SSendRemoveCPlayerSpellCooldownData(psd->getSpellId());
|
|
}*/
|
|
//}
|
|
|
|
//void Entity::SSendAddCPlayerSpellCooldownData(int spellId, float cooldown, float remainingCooldown) {
|
|
/*
|
|
if (CxNet::IsServer && (owner->Connection != null)) {
|
|
AddCPlayerSpellCooldownDataMsg addCPlayerSpellCooldownDataMsg = AddCPlayerSpellCooldownDataMsg();
|
|
addCPlayerSpellCooldownDataMsg.SpellId = spellId;
|
|
addCPlayerSpellCooldownDataMsg.Cooldown = cooldown;
|
|
addCPlayerSpellCooldownDataMsg.RemainingCooldown = remainingCooldown;
|
|
addCPlayerSpellCooldownDataMsg.Serialize(CxNet::NetBuffer);
|
|
owner->Connection->SendBuffer(0, CxNet::NetBuffer);
|
|
}*/
|
|
//}
|
|
|
|
void Entity::ssend_remove_cplayer_spell_cooldown_data(int spellId) {
|
|
/*
|
|
if (CxNet::IsServer && (owner->Connection != null)) {
|
|
RemoveCPlayerSpellCooldownDataMsg removeCPlayerSpellCooldownDataMsg = RemoveCPlayerSpellCooldownDataMsg();
|
|
removeCPlayerSpellCooldownDataMsg.SpellId = spellId;
|
|
removeCPlayerSpellCooldownDataMsg.Serialize(CxNet::NetBuffer);
|
|
owner->Connection->SendBuffer(0, CxNet::NetBuffer);
|
|
}*/
|
|
}
|
|
void Entity::creceive_add_cplayer_spell_cooldown_data(int spellId, float cooldown, float remainingCooldown) {
|
|
//AddCSpellData(new PlayerSpellCooldownData(spellId, cooldown, remainingCooldown));
|
|
}
|
|
|
|
void Entity::creceive_remove_cplayer_spell_cooldown_data(int spellId) {
|
|
//RemoveCSpellData(spellId, /*ERROR: Cannot translate: System.NotImplementedException: typeOfExpression: --> TODO: --> http://www.boost.org/doc/libs/1_55_0/doc/html/typeof/tuto.html. Node: ICSharpCode.NRefactory.CSharp.TypeOfExpression*/);
|
|
}
|
|
|
|
//void Entity::RemoveCSpellData(int spellId, Type *type) {
|
|
/*
|
|
PlayerSpellData *playerSpellData = null;
|
|
for (int i = 0; i < cSpellData->Count; i += 1) {
|
|
if ((cSpellData->GetData(i)->SpellId == spellId) && (cSpellData->GetData(i)->GetType() == *type)) {
|
|
playerSpellData = cSpellData->GetData(i);
|
|
cSpellData->RemoveAt(i);
|
|
break;
|
|
}
|
|
}
|
|
if ((COnSpellDataRemoved != null) && (playerSpellData != null)) {
|
|
DELEGATE_INVOKE(COnSpellDataRemoved, playerSpellData);
|
|
}*/
|
|
//}
|
|
|
|
//// Inventory ////
|
|
|
|
Vector<ItemInstance *> *Entity::get_sinventory() {
|
|
return _s_inventory;
|
|
}
|
|
|
|
Vector<ItemInstance *> *Entity::get_cinventory() {
|
|
return _c_inventory;
|
|
}
|
|
|
|
void Entity::sadd_craft_material(int itemId, int count) {
|
|
/*
|
|
for (int i = 0; i < sCraftMaterialInventory->Count; i += 1) {
|
|
ItemInstance *itemInstance = sCraftMaterialInventory->GetData(i);
|
|
if (itemInstance->getItemID() == itemId) {
|
|
ItemInstance *expr_1B = itemInstance;
|
|
expr_1B->setCount(count);
|
|
SSendAddCraftMaterial(itemId, count);
|
|
if (SOnCraftMaterialAdded != null) {
|
|
DELEGATE_INVOKE(SOnCraftMaterialAdded, itemInstance);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
ItemInstance *itemInstance2 = new ItemInstance(itemId, count);
|
|
sCraftMaterialInventory->Add(itemInstance2);
|
|
SSendAddCraftMaterial(itemId, count);
|
|
if (SOnCraftMaterialAdded != null) {
|
|
DELEGATE_INVOKE(SOnCraftMaterialAdded, itemInstance2);
|
|
}*/
|
|
}
|
|
|
|
void Entity::sremove_craft_material(int itemId, int count) {
|
|
/*
|
|
for (int i = 0; i < sCraftMaterialInventory->Count; i += 1) {
|
|
ItemInstance *itemInstance = sCraftMaterialInventory->GetData(i);
|
|
if (itemInstance->getItemID() == itemId) {
|
|
ItemInstance *expr_21 = itemInstance;
|
|
expr_21->setCount(count);
|
|
if (itemInstance->getCount() <= 0) {
|
|
if (itemInstance->getCount() < 0) {
|
|
Array<Object> *expr_46 = new Array<Object>(4);
|
|
expr_46->SetData(0, new String("inventory->SRemoveCraftMaterial: Material count was less than 0. Itemid="));
|
|
expr_46->SetData(1, BOX<int>(itemId));
|
|
expr_46->SetData(2, new String(" player="));
|
|
expr_46->SetData(3, owner->gameObject->name);
|
|
Debug::Log(String::Concat(expr_46));
|
|
}
|
|
sCraftMaterialInventory->RemoveAt(i);
|
|
}
|
|
SSendRemoveCraftMaterial(itemId, count);
|
|
if (SOnCraftMaterialRemoved != null) {
|
|
DELEGATE_INVOKE(SOnCraftMaterialRemoved);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
Array<Object> *expr_BF = new Array<Object>(4);
|
|
expr_BF->SetData(0, new String("inventory->SRemoveCraftMaterial: Material didn't exist in player's inventory. Itemid="));
|
|
expr_BF->SetData(1, BOX<int>(itemId));
|
|
expr_BF->SetData(2, new String(" player="));
|
|
expr_BF->SetData(3, owner->gameObject->name);
|
|
Debug::Log(String::Concat(expr_BF));*/
|
|
}
|
|
|
|
bool Entity::stry_to_add_item(int itemId, int count) {
|
|
/*
|
|
int num = -1;
|
|
for (int i = 0; i < getSInventory()->Count; i += 1) {
|
|
ItemInstance *itemInstance = getSInventory()->GetData(i);
|
|
if (itemInstance == null) {
|
|
if (num == -1) {
|
|
num = i;
|
|
}
|
|
} else {
|
|
if (itemInstance->getItemID() == itemId) {
|
|
ItemInstance *expr_28 = itemInstance;
|
|
expr_28->setCount(count);
|
|
SSendAddItem(i, itemId, count);
|
|
if (SOnItemAdded != null) {
|
|
DELEGATE_INVOKE(SOnItemAdded, itemInstance);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (num == -1) {
|
|
return false;
|
|
}
|
|
ItemInstance *itemInstance2 = new ItemInstance(itemId, count);
|
|
getSInventory()->SetData(num, itemInstance2);
|
|
SSendAddItem(num, itemId, count);
|
|
if (SOnItemAdded != null) {
|
|
DELEGATE_INVOKE(SOnItemAdded, itemInstance2);
|
|
}
|
|
return true;*/
|
|
|
|
return false;
|
|
}
|
|
|
|
bool Entity::stry_to_remove_item(int itemId, int count) {
|
|
/*
|
|
int i = 0;
|
|
while (i < getSInventory()->Count) {
|
|
ItemInstance *itemInstance = getSInventory()->GetData(i);
|
|
if ((itemInstance != null) && (itemInstance->getItemID() == itemId)) {
|
|
if (itemInstance->getCount() < count) {
|
|
return false;
|
|
}
|
|
if (itemInstance->getCount() == count) {
|
|
getSInventory()->SetData(i, null);
|
|
if (SOnItemRemoved != null) {
|
|
DELEGATE_INVOKE(SOnItemRemoved);
|
|
}
|
|
SSendRemoveItem(i);
|
|
return true;
|
|
}
|
|
ItemInstance *expr_5E = itemInstance;
|
|
expr_5E->setCount(count);
|
|
SSendChangeItemCount(i, itemInstance->getCount());
|
|
if (SOnItemCountChanged != null) {
|
|
DELEGATE_INVOKE(SOnItemCountChanged, itemInstance);
|
|
}
|
|
return true;
|
|
} else {
|
|
i += 1;
|
|
}
|
|
}
|
|
return false;*/
|
|
|
|
return false;
|
|
}
|
|
|
|
void Entity::ssend_add_item(int slotId, int itemId, int count) {
|
|
/*
|
|
if (CxNet::IsServer && (owner->Connection != null)) {
|
|
SSendAddItemMsg sSendAddItemMsg = SSendAddItemMsg();
|
|
sSendAddItemMsg.SlotId = slotId;
|
|
sSendAddItemMsg.ItemId = itemId;
|
|
sSendAddItemMsg.Count = count;
|
|
sSendAddItemMsg.Serialize(CxNet::NetBuffer);
|
|
owner->Connection->SendBuffer(0, CxNet::NetBuffer);
|
|
}*/
|
|
}
|
|
|
|
void Entity::ssend_change_item_count(int slotId, int count) {
|
|
/*
|
|
if (CxNet::IsServer && (owner->Connection != null)) {
|
|
SSendChangeItemCountMsg sSendChangeItemCountMsg = SSendChangeItemCountMsg();
|
|
sSendChangeItemCountMsg.SlotId = slotId;
|
|
sSendChangeItemCountMsg.Count = count;
|
|
sSendChangeItemCountMsg.Serialize(CxNet::NetBuffer);
|
|
owner->Connection->SendBuffer(0, CxNet::NetBuffer);
|
|
}*/
|
|
}
|
|
|
|
void Entity::ssend_remove_item(int slotId) {
|
|
/*
|
|
if (CxNet::IsServer && (owner->Connection != null)) {
|
|
SSendRemoveItemMsg sSendRemoveItemMsg = SSendRemoveItemMsg();
|
|
sSendRemoveItemMsg.SlotId = slotId;
|
|
sSendRemoveItemMsg.Serialize(CxNet::NetBuffer);
|
|
owner->Connection->SendBuffer(0, CxNet::NetBuffer);
|
|
}*/
|
|
}
|
|
|
|
void Entity::ssend_move_item(int slot1, int slot2) {
|
|
/*
|
|
if (CxNet::IsServer && (owner->Connection != null)) {
|
|
SSendMoveItemMsg sSendMoveItemMsg = SSendMoveItemMsg();
|
|
sSendMoveItemMsg.Slot1 = slot1;
|
|
sSendMoveItemMsg.Slot2 = slot2;
|
|
sSendMoveItemMsg.Serialize(CxNet::NetBuffer);
|
|
owner->Connection->SendBuffer(0, CxNet::NetBuffer);
|
|
}*/
|
|
}
|
|
|
|
void Entity::ssend_sent_items(String items) {
|
|
/*
|
|
if (CxNet::IsServer && (owner->Connection != null)) {
|
|
SSendSentItemsMsg sSendSentItemsMsg = SSendSentItemsMsg();
|
|
sSendSentItemsMsg.Items = items;
|
|
sSendSentItemsMsg.Serialize(CxNet::NetBuffer);
|
|
owner->Connection->SendBuffer(0, CxNet::NetBuffer);
|
|
}*/
|
|
}
|
|
|
|
void Entity::csend_swap_items(int slot1, int slot2) {
|
|
/*
|
|
if (CxNet::IsServer && (owner->Connection != null)) {
|
|
CSendSwapItemsMsg cSendSwapItemsMsg = CSendSwapItemsMsg();
|
|
cSendSwapItemsMsg.Slot1 = slot1;
|
|
cSendSwapItemsMsg.Slot2 = slot2;
|
|
cSendSwapItemsMsg.Serialize(CxNet::NetBuffer);
|
|
CxNet::SendBufferToServer(0);
|
|
}*/
|
|
}
|
|
|
|
void Entity::csend_craft_item_request(int craftId) {
|
|
/*
|
|
if (CxNet::IsServer && (owner->Connection != null)) {
|
|
CSendCraftItemRequestMsg cSendCraftItemRequestMsg = CSendCraftItemRequestMsg();
|
|
cSendCraftItemRequestMsg.CraftId = craftId;
|
|
cSendCraftItemRequestMsg.Serialize(CxNet::NetBuffer);
|
|
CxNet::SendBufferToServer(0);
|
|
}*/
|
|
}
|
|
|
|
void Entity::ssend_add_craft_material(int itemId, int count) {
|
|
/*
|
|
if (CxNet::IsServer && (owner->Connection != null)) {
|
|
SSendAddCraftMaterialMsg sSendAddCraftMaterialMsg = SSendAddCraftMaterialMsg();
|
|
sSendAddCraftMaterialMsg.ItemId = itemId;
|
|
sSendAddCraftMaterialMsg.Count = count;
|
|
sSendAddCraftMaterialMsg.Serialize(CxNet::NetBuffer);
|
|
owner->Connection->SendBuffer(0, CxNet::NetBuffer);
|
|
}*/
|
|
}
|
|
|
|
void Entity::ssend_remove_craft_material(int itemId, int count) {
|
|
/*
|
|
if (CxNet::IsServer && (owner->Connection != null)) {
|
|
SSendRemoveCraftMaterialMsg sSendRemoveCraftMaterialMsg = SSendRemoveCraftMaterialMsg();
|
|
sSendRemoveCraftMaterialMsg.ItemId = itemId;
|
|
sSendRemoveCraftMaterialMsg.Count = count;
|
|
sSendRemoveCraftMaterialMsg.Serialize(CxNet::NetBuffer);
|
|
owner->Connection->SendBuffer(0, CxNet::NetBuffer);
|
|
}*/
|
|
}
|
|
|
|
void Entity::ssend_sent_craft_materials(String materials) {
|
|
/*
|
|
if (CxNet::IsServer && (owner->Connection != null)) {
|
|
SSendSentCraftMaterialsMsg sSendSentCraftMaterialsMsg = SSendSentCraftMaterialsMsg();
|
|
sSendSentCraftMaterialsMsg.Materials = materials;
|
|
sSendSentCraftMaterialsMsg.Serialize(CxNet::NetBuffer);
|
|
owner->Connection->SendBuffer(0, CxNet::NetBuffer);
|
|
}*/
|
|
}
|
|
|
|
void Entity::creceive_add_item(int slotId, int itemId, int count) {
|
|
/*
|
|
if (getCInventory()->GetData(slotId) == null) {
|
|
getCInventory()->SetData(slotId, new ItemInstance(itemId, count));
|
|
} else {
|
|
if (getCInventory()->GetData(slotId)->ItemID != itemId) {
|
|
Array<Object> *expr_40 = new Array<Object>(6);
|
|
expr_40->SetData(0, new String("Item did not match in slot "));
|
|
expr_40->SetData(1, BOX<int>(slotId));
|
|
expr_40->SetData(2, new String(" "));
|
|
expr_40->SetData(3, BOX<int>(itemId));
|
|
expr_40->SetData(4, new String(" orig id: "));
|
|
expr_40->SetData(5, BOX<int>(getCInventory()->GetData(slotId)->ItemID));
|
|
Debug::Log(String::Concat(expr_40));
|
|
getCInventory()->GetData(slotId)->ItemID = itemId;
|
|
}
|
|
ItemInstance *expr_AB = getCInventory()->GetData(slotId);
|
|
expr_AB->setCount(count);
|
|
}
|
|
if (COnItemAdded != null) {
|
|
DELEGATE_INVOKE(COnItemAdded, getCInventory()->GetData(slotId));
|
|
}*/
|
|
}
|
|
|
|
void Entity::creceive_change_item_count(int slotId, int count) {
|
|
/*
|
|
if (getCInventory()->GetData(slotId) == null) {
|
|
return;
|
|
}
|
|
getCInventory()->GetData(slotId)->ItemID = count;
|
|
if (COnItemCountChanged != null) {
|
|
DELEGATE_INVOKE(COnItemCountChanged, getCInventory()->GetData(slotId));
|
|
}*/
|
|
}
|
|
|
|
void Entity::creceive_remove_item(int slotId) {
|
|
/*
|
|
getCInventory()->SetData(slotId, null);
|
|
if (COnItemRemoved != null) {
|
|
DELEGATE_INVOKE(COnItemRemoved);
|
|
}*/
|
|
}
|
|
|
|
void Entity::creceive_move_item(int slot1, int slot2) {
|
|
/*
|
|
if ((slot1 >= getCInventory()->Count) || (slot2 >= getCInventory()->Count)) {
|
|
return;
|
|
}
|
|
if ((getCInventory()->GetData(slot1) == null) && (getCInventory()->GetData(slot2) == null)) {
|
|
return;
|
|
}
|
|
ItemInstance *value = getCInventory()->GetData(slot1);
|
|
getCInventory()->SetData(slot1, getCInventory()->GetData(slot2));
|
|
getCInventory()->SetData(slot2, value);
|
|
if (COnItemMoved != null) {
|
|
DELEGATE_INVOKE(COnItemMoved);
|
|
}*/
|
|
}
|
|
|
|
void Entity::creceive_add_craft_material(int itemId, int count) {
|
|
/*
|
|
for (int i = 0; i < cCraftMaterialInventory->Count; i += 1) {
|
|
ItemInstance *itemInstance = cCraftMaterialInventory->GetData(i);
|
|
if (itemInstance->getItemID() == itemId) {
|
|
ItemInstance *expr_1B = itemInstance;
|
|
expr_1B->setCount(count);
|
|
if (COnCraftMaterialAdded != null) {
|
|
DELEGATE_INVOKE(COnCraftMaterialAdded, itemInstance);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
ItemInstance *itemInstance2 = new ItemInstance(itemId, count);
|
|
cCraftMaterialInventory->Add(itemInstance2);
|
|
if (COnCraftMaterialAdded != null) {
|
|
DELEGATE_INVOKE(COnCraftMaterialAdded, itemInstance2);
|
|
}*/
|
|
}
|
|
|
|
void Entity::creceive_remove_craft_material(int itemId, int count) {
|
|
/*
|
|
for (int i = 0; i < getCCraftMaterialInventory()->Count; i += 1) {
|
|
ItemInstance *itemInstance = getCCraftMaterialInventory()->GetData(i);
|
|
if (itemInstance->getItemID() == itemId) {
|
|
ItemInstance *expr_1B = itemInstance;
|
|
expr_1B->setCount(count);
|
|
if (itemInstance->getCount() <= 0) {
|
|
getCCraftMaterialInventory()->RemoveAt(i);
|
|
}
|
|
if (COnCraftMaterialRemoved != null) {
|
|
DELEGATE_INVOKE(COnCraftMaterialRemoved);
|
|
}
|
|
return;
|
|
}
|
|
}*/
|
|
}
|
|
|
|
void Entity::creceive_sent_craft_materials(String materials) {
|
|
/*
|
|
Array<char> *expr_07 = new Array<char>(1);
|
|
expr_07->SetData(0, ';');
|
|
Array<String> *array = materials->Split(expr_07);
|
|
for (int i = 0; i < (array->Length - 1); i += 1) {
|
|
String arg_24_0 = array->GetData(i);
|
|
Array<char> *expr_1F = new Array<char>(1);
|
|
expr_1F->SetData(0, '=');
|
|
Array<String> *array2 = arg_24_0->Split(expr_1F);
|
|
ItemInstance *item = new ItemInstance(BSConvert::ToInt(array2->GetData(0)), BSConvert::ToInt(array2->GetData(1)));
|
|
getCCraftMaterialInventory()->Add(item);
|
|
}
|
|
if (COnCraftMaterialsLoaded != null) {
|
|
DELEGATE_INVOKE(COnCraftMaterialsLoaded);
|
|
}*/
|
|
}
|
|
|
|
void Entity::creceive_sent_items(String items) {
|
|
/*
|
|
Array<char> *expr_07 = new Array<char>(1);
|
|
expr_07->SetData(0, ';');
|
|
Array<String> *array = items->Split(expr_07);
|
|
for (int i = 0; i < (array->Length - 1); i += 1) {
|
|
String arg_24_0 = array->GetData(i);
|
|
Array<char> *expr_1F = new Array<char>(1);
|
|
expr_1F->SetData(0, '=');
|
|
Array<String> *array2 = arg_24_0->Split(expr_1F);
|
|
ItemInstance *value = new ItemInstance(BSConvert::ToInt(array2->GetData(1)), BSConvert::ToInt(array2->GetData(2)));
|
|
getCInventory()->SetData(BSConvert::ToInt(array2->GetData(0)), value);
|
|
}
|
|
if (COnItemsLoaded != null) {
|
|
DELEGATE_INVOKE(COnItemsLoaded);
|
|
}*/
|
|
}
|
|
|
|
void Entity::sreceive_swap_items(int slot1, int slot2) {
|
|
/*
|
|
if ((slot1 >= getSInventory()->Count) || (slot2 >= getSInventory()->Count)) {
|
|
return;
|
|
}
|
|
if ((getSInventory()->GetData(slot1) == null) && (getSInventory()->GetData(slot2) == null)) {
|
|
return;
|
|
}
|
|
ItemInstance *value = getSInventory()->GetData(slot1);
|
|
getSInventory()->SetData(slot1, getSInventory()->GetData(slot2));
|
|
getSInventory()->SetData(slot2, value);
|
|
SSendMoveItem(slot1, slot2);
|
|
if (SOnItemMoved != null) {
|
|
DELEGATE_INVOKE(SOnItemMoved);
|
|
}*/
|
|
}
|
|
|
|
void Entity::send_all_items() {
|
|
/*
|
|
StringBuilder *StringBuilder = new StringBuilder();
|
|
for (int i = 0; i < getSCraftMaterialInventory()->Count; i += 1) {
|
|
StringBuilder->Append(getSCraftMaterialInventory()->GetData(i)->ItemID);
|
|
StringBuilder->Append('=');
|
|
StringBuilder->Append(getSCraftMaterialInventory()->GetData(i)->Count);
|
|
StringBuilder->Append(';');
|
|
if (StringBuilder->Length >= 700) {
|
|
SSendSentCraftMaterials(StringBuilder->ToString());
|
|
StringBuilder->Remove(0, StringBuilder->Length);
|
|
}
|
|
}
|
|
SSendSentCraftMaterials(StringBuilder->ToString());
|
|
if (StringBuilder->Length > 0) {
|
|
StringBuilder->Remove(0, StringBuilder->Length);
|
|
}
|
|
for (int j = 0; j < getSInventory()->Count; j += 1) {
|
|
if (getSInventory()->GetData(j) != null) {
|
|
StringBuilder->Append(j);
|
|
StringBuilder->Append('=');
|
|
StringBuilder->Append(getSInventory()->GetData(j)->ItemID);
|
|
StringBuilder->Append('=');
|
|
StringBuilder->Append(getSInventory()->GetData(j)->Count);
|
|
StringBuilder->Append(';');
|
|
}
|
|
}
|
|
SSendSentItems(StringBuilder->ToString());*/
|
|
}
|
|
|
|
bool Entity::shas_craft_material(int itemId, int count) {
|
|
/*
|
|
for (int i = 0; i < getSCraftMaterialInventory()->Count; i += 1) {
|
|
if ((getSCraftMaterialInventory()->GetData(i)->ItemID == itemId) && (getSCraftMaterialInventory()->GetData(i)->Count >= count)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;*/
|
|
|
|
return false;
|
|
}
|
|
|
|
bool Entity::shas_item(int itemId, int count) {
|
|
/*
|
|
for (int i = 0; i < getSInventory()->Count; i += 1) {
|
|
if (((getSInventory()->GetData(i) != null) && (getSInventory()->GetData(i)->ItemID == itemId)) && (getSInventory()->GetData(i)->Count >= count)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;*/
|
|
|
|
return false;
|
|
}
|
|
|
|
bool Entity::chas_craft_material(int itemId, int count) {
|
|
/*
|
|
for (int i = 0; i < getCCraftMaterialInventory()->Count; i += 1) {
|
|
if ((getCCraftMaterialInventory()->GetData(i)->ItemID == itemId) && (getCCraftMaterialInventory()->GetData(i)->Count >= count)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;*/
|
|
|
|
return false;
|
|
}
|
|
|
|
bool Entity::chas_item(int itemId, int count) {
|
|
/*
|
|
for (int i = 0; i < getCInventory()->Count; i += 1) {
|
|
if (((getCInventory()->GetData(i) != null) && (getCInventory()->GetData(i)->ItemID == itemId)) && (getCInventory()->GetData(i)->Count >= count)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;*/
|
|
|
|
return false;
|
|
}
|
|
|
|
int Entity::cget_item_count(int itemId) {
|
|
/*
|
|
for (int i = 0; i < getCInventory()->Count; i += 1) {
|
|
if ((getCInventory()->GetData(i) != null) && (getCInventory()->GetData(i)->ItemID == itemId)) {
|
|
return getCInventory()->GetData(i)->Count;
|
|
}
|
|
}
|
|
return 0;*/
|
|
|
|
return 0;
|
|
}
|
|
|
|
int Entity::sget_item_count(int itemId) {
|
|
/*
|
|
for (int i = 0; i < getSInventory()->Count; i += 1) {
|
|
if ((getSInventory()->GetData(i) != null) && (getSInventory()->GetData(i)->ItemID == itemId)) {
|
|
return getSInventory()->GetData(i)->Count;
|
|
}
|
|
}
|
|
return 0;*/
|
|
|
|
return 0;
|
|
}
|
|
|
|
int Entity::cget_craft_material_count(int itemId) {
|
|
/*
|
|
for (int i = 0; i < getCCraftMaterialInventory()->Count; i += 1) {
|
|
if (getCCraftMaterialInventory()->GetData(i)->ItemID == itemId) {
|
|
return getCCraftMaterialInventory()->GetData(i)->Count;
|
|
}
|
|
}
|
|
return 0;*/
|
|
|
|
return 0;
|
|
}
|
|
|
|
int Entity::sget_craft_material_count(int itemId) {
|
|
/*
|
|
for (int i = 0; i < getSCraftMaterialInventory()->Count; i += 1) {
|
|
if (getSCraftMaterialInventory()->GetData(i)->ItemID == itemId) {
|
|
return getSCraftMaterialInventory()->GetData(i)->Count;
|
|
}
|
|
}
|
|
return 0;*/
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool Entity::ccan_craft(CraftDataAttribute *cda) {
|
|
/*
|
|
for (int i = 0; i < cda->RequiredItems->Count; i += 1) {
|
|
if (!CHasItem(cda->RequiredItems->GetData(i), 1)) {
|
|
return false;
|
|
}
|
|
}
|
|
for (int j = 0; j < cda->RequiredMaterials->Count; j += 1) {
|
|
CraftDataAttributeHelper *craftDataAttributeHelper = cda->RequiredMaterials->GetData(j);
|
|
if (!CHasCraftMaterial(craftDataAttributeHelper->ItemId, craftDataAttributeHelper->Count)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;*/
|
|
|
|
return false;
|
|
}
|
|
|
|
bool Entity::ctry_to_craft(CraftDataAttribute *cda) {
|
|
/*
|
|
if (!CCanCraft(cda)) {
|
|
return false;
|
|
}
|
|
CSendCraftItemRequest(cda->Id);
|
|
return true;*/
|
|
|
|
return false;
|
|
}
|
|
|
|
bool Entity::scan_craft(CraftDataAttribute *cda) {
|
|
/*
|
|
for (int i = 0; i < cda->RequiredItems->Count; i += 1) {
|
|
if (!SHasItem(cda->RequiredItems->GetData(i), 1)) {
|
|
return false;
|
|
}
|
|
}
|
|
for (int j = 0; j < cda->RequiredMaterials->Count; j += 1) {
|
|
CraftDataAttributeHelper *craftDataAttributeHelper = cda->RequiredMaterials->GetData(j);
|
|
if (!SHasCraftMaterial(craftDataAttributeHelper->ItemId, craftDataAttributeHelper->Count)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;*/
|
|
|
|
return false;
|
|
}
|
|
|
|
void Entity::scraft(CraftDataAttribute *cda) {
|
|
/*
|
|
if (!STryToAddItem(cda->Item->ItemId, cda->Item->Count)) {
|
|
return;
|
|
}
|
|
for (int i = 0; i < cda->RequiredMaterials->Count; i += 1) {
|
|
CraftDataAttributeHelper *craftDataAttributeHelper = cda->RequiredMaterials->GetData(i);
|
|
SRemoveCraftMaterial(craftDataAttributeHelper->ItemId, craftDataAttributeHelper->Count);
|
|
}*/
|
|
}
|
|
|
|
void Entity::sreceive_craft_item_msg(int craftId) {
|
|
/*
|
|
CraftDataLoader *instance = CraftDataLoader::Instance;
|
|
if (instance == null) {
|
|
return;
|
|
}
|
|
CraftDataAttribute *craftDataWithId = instance->getCraftDataWithId(craftId);
|
|
if (craftDataWithId == null) {
|
|
return;
|
|
}
|
|
if (!SCanCraft(craftDataWithId)) {
|
|
return;
|
|
}
|
|
SCraft(craftDataWithId);*/
|
|
}
|
|
|
|
void Entity::cswap_items_in_slots(int slot1, int slot2) {
|
|
/*
|
|
if ((slot1 >= getCInventory()->Count) || (slot2 >= getCInventory()->Count)) {
|
|
return;
|
|
}
|
|
if ((getCInventory()->GetData(slot1) == null) && (getCInventory()->GetData(slot2) == null)) {
|
|
return;
|
|
}
|
|
CSendSwapItems(slot1, slot2); */
|
|
}
|
|
|
|
void Entity::loaded() {
|
|
//sendstate = true;
|
|
}
|
|
|
|
//// PlayerData ////
|
|
|
|
void Entity::reward_xp_for_mob(int level) {
|
|
/*
|
|
int l = level - Level;
|
|
|
|
if (Mathf.Abs(l) > 5) {
|
|
if (l < 0) {
|
|
l = -5;
|
|
} else {
|
|
l = 5;
|
|
}
|
|
}
|
|
|
|
l += 5;
|
|
|
|
Xp += (l * 20);*/
|
|
}
|
|
|
|
void Entity::level_up(int num) {
|
|
/*
|
|
Xp = 0;
|
|
Level += num;
|
|
|
|
if (SOnLevelUp != null) {
|
|
SOnLevelUp(owner);
|
|
}
|
|
|
|
RpcLevelUp();*/
|
|
}
|
|
|
|
void Entity::set_level_without_modifiers(int newLevel, bool a) {
|
|
/*
|
|
level = newLevel;
|
|
|
|
if (SOnLevelChanged != null) {
|
|
SOnLevelChanged(owner, newLevel);
|
|
}*/
|
|
}
|
|
|
|
void Entity::apply_level_modifiers() {
|
|
/*
|
|
owner.Stats.SHealth.Modifiers.Remove(-10);
|
|
|
|
owner.Stats.SHealth.Modifiers.Add(-10, 0f, -((1 - character.Stats.HPScaling.Evaluate((float)Level)) * 100f));*/
|
|
}
|
|
|
|
void Entity::rpc_level_up() {
|
|
/*
|
|
if (COnLevelUp != null) {
|
|
COnLevelUp(owner);
|
|
}*/
|
|
}
|
|
|
|
void Entity::registers() {
|
|
/*
|
|
if (aiPlayer) {
|
|
Entity.CRegisterAIPlayer(GUID, owner);
|
|
|
|
if (owner.isServer) {
|
|
Entity.SRegisterAIPlayer(GUID, owner);
|
|
}
|
|
|
|
// owner.OnPlayerSpawned(owner, owner.isClient, owner.isServer, owner.isLocalPlayer);
|
|
|
|
return;
|
|
}
|
|
|
|
if (isLocalPlayer) {
|
|
Entity.RegisterLocalPlayer(GUID, owner);
|
|
|
|
//Let's call the playerFactory, so it can modify this instance
|
|
// owner.OnPlayerSpawned(owner, owner.isClient, owner.isServer, owner.isLocalPlayer);
|
|
|
|
return;
|
|
}
|
|
|
|
if (owner.isClient) {
|
|
Entity.CRegisterNetworkedPlayer(GUID, owner);
|
|
|
|
if (owner.isServer) {
|
|
Entity.SRegisterNetworkedPlayer(GUID, owner);
|
|
}
|
|
|
|
//Let's call the playerFactory, so it can modify this instance
|
|
// owner.OnPlayerSpawned(owner, owner.isClient, owner.isServer, owner.isLocalPlayer);
|
|
}
|
|
*/
|
|
|
|
/*
|
|
pl.CRegisterAIPlayer(transform.gameObject);
|
|
|
|
if (isServer)
|
|
{
|
|
pl.SRegisterAIPlayer(transform.gameObject);
|
|
}
|
|
|
|
//Let's call the playerFactory, so it can modify this instance
|
|
pf.OnPlayerSpawned(gameObject, isClient, isServer, isLocalPlayer);*/
|
|
}
|
|
|
|
void Entity::update(float delta) {
|
|
update_auras(delta);
|
|
|
|
if (_s_spell_cast_info.is_valid() && _s_spell_cast_info->get_is_casting()) {
|
|
if (_s_spell_cast_info->update_cast_time(delta)) {
|
|
sfinish_cast();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Entity::Update() {
|
|
/*
|
|
getInventory()->Update();
|
|
getPlayerFacingComponent()->Update();
|
|
getStateComponent()->Update();
|
|
getPlayerSpellDataComponent()->Update();
|
|
getOpmcc()->Update();
|
|
getEntity()->Update();
|
|
getFactionComponent()->Update();*/
|
|
|
|
/*
|
|
if (owner->isServer && sendstate) {
|
|
sendstate = false;
|
|
SendAllItems();
|
|
} */
|
|
|
|
/*
|
|
if (send && owner->isServer) {
|
|
send = false;
|
|
for (int i = 0; i < getSSpellData()->Count; i += 1) {
|
|
PlayerSpellData *playerSpellData = getSSpellData()->GetData(i);
|
|
if (is_inst_of<PlayerSpellCooldownData *>(playerSpellData)) {
|
|
PlayerSpellCooldownData *playerSpellCooldownData = as_cast<PlayerSpellCooldownData *>(playerSpellData);
|
|
SSendAddCPlayerSpellCooldownData(playerSpellCooldownData->SpellId, playerSpellCooldownData->getCooldown(), playerSpellCooldownData->getRemainingCooldown());
|
|
}
|
|
}
|
|
}
|
|
for (int j = 0; j < sSpellData->Count; j += 1) {
|
|
sSpellData->GetData(j)->Update(this);
|
|
}
|
|
for (int k = 0; k < cSpellData->Count; k += 1) {
|
|
cSpellData->GetData(k)->Update(this);
|
|
}*/
|
|
|
|
/*
|
|
if (owner->PlayerData->State != PlayerStates::STATE_NORMAL) {
|
|
return;
|
|
}
|
|
if (getSCasting()) {
|
|
setSCurrentCastTime(Time::deltaTime);
|
|
if (getSCurrentCastTime() >= getSCastTime()) {
|
|
SCastFinished();
|
|
}
|
|
}
|
|
if (getCCasting()) {
|
|
setCCurrentCastTime(Time::deltaTime);
|
|
if (getCCurrentCastTime() >= getCCastTime()) {
|
|
CCastFinished();
|
|
}
|
|
}*/
|
|
}
|
|
|
|
String Entity::request_spell_name(int spellId) {
|
|
return "";
|
|
}
|
|
|
|
String Entity::request_spell_description(int spellId, int level) {
|
|
return "";
|
|
}
|
|
|
|
String Entity::random_name() {
|
|
/*/
|
|
String text = new String(l1->GetData(UnityEngine::Random::Range(0, l1->Length)));
|
|
bool flag = true;
|
|
int num = UnityEngine::Random::Range(3, 6);
|
|
for (int i = 0; i < num; i += 1) {
|
|
if (flag) {
|
|
*text += *(new String(l3->GetData(UnityEngine::Random::Range(0, l3->Length))));
|
|
} else {
|
|
*text += *(new String(l2->GetData(UnityEngine::Random::Range(0, l2->Length))));
|
|
}
|
|
}
|
|
return text;*/
|
|
|
|
return "";
|
|
}
|
|
|
|
void Entity::_notification(int p_what) {
|
|
switch (p_what) {
|
|
case NOTIFICATION_ENTER_TREE: {
|
|
if (!Engine::get_singleton()->is_editor_hint())
|
|
set_process(true);
|
|
|
|
Node *node = get_node_or_null(_character_skeleton_path);
|
|
|
|
if (node != NULL) {
|
|
_character_skeleton = Object::cast_to<CharacterSkeleton>(node);
|
|
} else {
|
|
_character_skeleton = NULL;
|
|
}
|
|
} break;
|
|
case NOTIFICATION_PROCESS: {
|
|
update(get_process_delta_time());
|
|
} break;
|
|
case NOTIFICATION_EXIT_TREE: {
|
|
|
|
} break;
|
|
}
|
|
}
|
|
|
|
void Entity::_bind_methods() {
|
|
//Signals
|
|
ADD_SIGNAL(MethodInfo("starget_changed", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity")));
|
|
ADD_SIGNAL(MethodInfo("ctarget_changed", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity")));
|
|
|
|
ADD_SIGNAL(MethodInfo("son_damage_taken", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "damage_pipeline_data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo")));
|
|
ADD_SIGNAL(MethodInfo("con_damage_taken", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "damage_pipeline_data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo")));
|
|
|
|
ADD_SIGNAL(MethodInfo("con_damage_dealt", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "damage_pipeline_data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo")));
|
|
|
|
ADD_SIGNAL(MethodInfo("scharacter_class_changed", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity")));
|
|
ADD_SIGNAL(MethodInfo("ccharacter_class_changed", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity")));
|
|
|
|
//SpellCastSignals
|
|
ADD_SIGNAL(MethodInfo("scast_started", PropertyInfo(Variant::OBJECT, "spell_cast_info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
|
|
ADD_SIGNAL(MethodInfo("scast_failed", PropertyInfo(Variant::OBJECT, "spell_cast_info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
|
|
ADD_SIGNAL(MethodInfo("scast_delayed", PropertyInfo(Variant::OBJECT, "spell_cast_info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
|
|
ADD_SIGNAL(MethodInfo("scast_finished", PropertyInfo(Variant::OBJECT, "spell_cast_info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
|
|
ADD_SIGNAL(MethodInfo("scast_interrupted", PropertyInfo(Variant::OBJECT, "spell_cast_info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
|
|
|
|
ADD_SIGNAL(MethodInfo("ccast_started", PropertyInfo(Variant::OBJECT, "spell_cast_info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
|
|
ADD_SIGNAL(MethodInfo("ccast_failed", PropertyInfo(Variant::OBJECT, "spell_cast_info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
|
|
ADD_SIGNAL(MethodInfo("ccast_delayed", PropertyInfo(Variant::OBJECT, "spell_cast_info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
|
|
ADD_SIGNAL(MethodInfo("ccast_finished", PropertyInfo(Variant::OBJECT, "spell_cast_info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
|
|
ADD_SIGNAL(MethodInfo("ccast_interrupted", PropertyInfo(Variant::OBJECT, "spell_cast_info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
|
|
|
|
//Aura signals
|
|
ADD_SIGNAL(MethodInfo("saura_added", PropertyInfo(Variant::OBJECT, "aura_data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
|
|
ADD_SIGNAL(MethodInfo("saura_removed", PropertyInfo(Variant::OBJECT, "aura_data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
|
|
ADD_SIGNAL(MethodInfo("saura_removed_expired", PropertyInfo(Variant::OBJECT, "aura_data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
|
|
ADD_SIGNAL(MethodInfo("saura_removed_dispelled", PropertyInfo(Variant::OBJECT, "aura_data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
|
|
|
|
ADD_SIGNAL(MethodInfo("caura_added", PropertyInfo(Variant::OBJECT, "aura_data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
|
|
ADD_SIGNAL(MethodInfo("caura_removed", PropertyInfo(Variant::OBJECT, "aura_data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
|
|
ADD_SIGNAL(MethodInfo("caura_removed_dispelled", PropertyInfo(Variant::OBJECT, "aura_data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
|
|
ADD_SIGNAL(MethodInfo("caura_removed_expired", PropertyInfo(Variant::OBJECT, "aura_data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
|
|
|
|
//EventHandlers
|
|
ClassDB::bind_method(D_METHOD("son_before_aura_applied", "data"), &Entity::son_before_aura_applied);
|
|
ClassDB::bind_method(D_METHOD("son_after_aura_applied", "data"), &Entity::son_after_aura_applied);
|
|
|
|
ClassDB::bind_method(D_METHOD("son_hit", "data"), &Entity::son_hit);
|
|
ClassDB::bind_method(D_METHOD("son_before_damage", "data"), &Entity::son_before_damage);
|
|
ClassDB::bind_method(D_METHOD("son_damage_receive", "data"), &Entity::son_damage_receive);
|
|
ClassDB::bind_method(D_METHOD("son_dealt_damage", "data"), &Entity::son_dealt_damage);
|
|
ClassDB::bind_method(D_METHOD("son_damage_dealt", "data"), &Entity::son_damage_dealt);
|
|
|
|
ClassDB::bind_method(D_METHOD("son_before_cast", "info"), &Entity::son_before_cast);
|
|
ClassDB::bind_method(D_METHOD("son_before_cast_target", "info"), &Entity::son_before_cast_target);
|
|
ClassDB::bind_method(D_METHOD("son_cast_finished_target", "info"), &Entity::son_cast_finished_target);
|
|
ClassDB::bind_method(D_METHOD("son_cast_finished", "info"), &Entity::son_cast_finished);
|
|
ClassDB::bind_method(D_METHOD("son_cast_started", "info"), &Entity::son_cast_started);
|
|
ClassDB::bind_method(D_METHOD("son_cast_failed", "info"), &Entity::son_cast_failed);
|
|
|
|
//Clientside EventHandlers
|
|
ClassDB::bind_method(D_METHOD("con_cast_failed", "info"), &Entity::con_cast_failed);
|
|
ClassDB::bind_method(D_METHOD("con_cast_started", "info"), &Entity::con_cast_started);
|
|
ClassDB::bind_method(D_METHOD("con_cast_state_changed", "info"), &Entity::con_cast_state_changed);
|
|
ClassDB::bind_method(D_METHOD("con_cast_finished", "info"), &Entity::con_cast_finished);
|
|
ClassDB::bind_method(D_METHOD("con_spell_cast_success", "info"), &Entity::con_spell_cast_success);
|
|
|
|
//Modifiers/Requesters
|
|
ClassDB::bind_method(D_METHOD("sapply_passives_damage_receive", "data"), &Entity::sapply_passives_damage_receive);
|
|
ClassDB::bind_method(D_METHOD("sapply_passives_damage_deal", "data"), &Entity::sapply_passives_damage_deal);
|
|
|
|
//Spell operations
|
|
ClassDB::bind_method(D_METHOD("scast_spell", "spell_id"), &Entity::scast_spell);
|
|
ClassDB::bind_method(D_METHOD("crequest_spell_cast", "spell_id"), &Entity::crequest_spell_cast);
|
|
|
|
//Damage Operations
|
|
ClassDB::bind_method(D_METHOD("stake_damage", "data"), &Entity::stake_damage);
|
|
ClassDB::bind_method(D_METHOD("sdeal_damage_to", "data"), &Entity::sdeal_damage_to);
|
|
|
|
//Aura Manipulation
|
|
ClassDB::bind_method(D_METHOD("sadd_aura", "aura"), &Entity::sadd_aura);
|
|
ClassDB::bind_method(D_METHOD("sremove_aura", "aura"), &Entity::sremove_aura);
|
|
ClassDB::bind_method(D_METHOD("sremove_aura_expired", "aura"), &Entity::sremove_aura_expired);
|
|
ClassDB::bind_method(D_METHOD("sremove_aura_dispelled", "aura"), &Entity::sremove_aura_dispelled);
|
|
|
|
ClassDB::bind_method(D_METHOD("cadd_aura", "aura"), &Entity::cadd_aura);
|
|
ClassDB::bind_method(D_METHOD("cremove_aura", "aura"), &Entity::cremove_aura);
|
|
ClassDB::bind_method(D_METHOD("cremove_aura_expired", "aura"), &Entity::cremove_aura_expired);
|
|
ClassDB::bind_method(D_METHOD("cremove_aura_dispelled", "aura"), &Entity::cremove_aura_dispelled);
|
|
|
|
ClassDB::bind_method(D_METHOD("sremove_auras_with_group", "aura_group"), &Entity::sremove_auras_with_group);
|
|
|
|
ClassDB::bind_method(D_METHOD("sget_aura_count"), &Entity::sget_aura_count);
|
|
ClassDB::bind_method(D_METHOD("sget_aura", "index"), &Entity::sget_aura);
|
|
|
|
ClassDB::bind_method(D_METHOD("cget_aura_count"), &Entity::cget_aura_count);
|
|
ClassDB::bind_method(D_METHOD("cget_aura", "index"), &Entity::cget_aura);
|
|
|
|
//Hooks
|
|
ClassDB::bind_method(D_METHOD("moved"), &Entity::moved);
|
|
|
|
//Properties
|
|
ClassDB::bind_method(D_METHOD("get_character_skeleton_path"), &Entity::get_character_skeleton_path);
|
|
ClassDB::bind_method(D_METHOD("set_character_skeleton_path", "value"), &Entity::set_character_skeleton_path);
|
|
ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "character_skeleton_path"), "set_character_skeleton_path", "get_character_skeleton_path");
|
|
|
|
ClassDB::bind_method(D_METHOD("gets_entity_type"), &Entity::gets_entity_type);
|
|
ClassDB::bind_method(D_METHOD("sets_entity_type", "value"), &Entity::sets_entity_type);
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "s_entity_type", PROPERTY_HINT_ENUM, "None, Player, AI, Mob"), "sets_entity_type", "gets_entity_type");
|
|
|
|
ClassDB::bind_method(D_METHOD("getc_entity_type"), &Entity::getc_entity_type);
|
|
ClassDB::bind_method(D_METHOD("setc_entity_type", "value"), &Entity::sets_entity_type);
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "c_entity_type", PROPERTY_HINT_ENUM, "None, Player, AI, Mob"), "setc_entity_type", "getc_entity_type");
|
|
|
|
ClassDB::bind_method(D_METHOD("gets_player_name"), &Entity::gets_player_name);
|
|
ClassDB::bind_method(D_METHOD("sets_player_name", "value"), &Entity::sets_player_name);
|
|
ADD_PROPERTY(PropertyInfo(Variant::STRING, "s_player_name"), "sets_player_name", "gets_player_name");
|
|
|
|
ClassDB::bind_method(D_METHOD("getc_player_name"), &Entity::getc_player_name);
|
|
ClassDB::bind_method(D_METHOD("setc_player_name", "value"), &Entity::setc_player_name);
|
|
ADD_PROPERTY(PropertyInfo(Variant::STRING, "c_player_name"), "setc_player_name", "getc_player_name");
|
|
|
|
ClassDB::bind_method(D_METHOD("gets_xp"), &Entity::gets_xp);
|
|
ClassDB::bind_method(D_METHOD("sets_xp", "value"), &Entity::sets_xp);
|
|
ADD_PROPERTY(PropertyInfo(Variant::STRING, "s_xp"), "sets_xp", "gets_xp");
|
|
|
|
ClassDB::bind_method(D_METHOD("getc_xp"), &Entity::getc_xp);
|
|
ClassDB::bind_method(D_METHOD("setc_xp", "value"), &Entity::setc_xp);
|
|
ADD_PROPERTY(PropertyInfo(Variant::STRING, "c_xp"), "setc_xp", "getc_xp");
|
|
|
|
ClassDB::bind_method(D_METHOD("gets_character_class"), &Entity::gets_character_class);
|
|
ClassDB::bind_method(D_METHOD("sets_character_class", "value"), &Entity::sets_character_class);
|
|
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "s_character_class", PROPERTY_HINT_RESOURCE_TYPE, "CharacterClass"), "sets_character_class", "gets_character_class");
|
|
|
|
ClassDB::bind_method(D_METHOD("getc_character_class"), &Entity::getc_character_class);
|
|
ClassDB::bind_method(D_METHOD("setc_character_class", "value"), &Entity::setc_character_class);
|
|
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "c_character_class", PROPERTY_HINT_RESOURCE_TYPE, "CharacterClass"), "setc_character_class", "getc_character_class");
|
|
|
|
ClassDB::bind_method(D_METHOD("initialize", "entity_create_info"), &Entity::initialize);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_health"), &Entity::get_health);
|
|
ClassDB::bind_method(D_METHOD("get_mana"), &Entity::get_mana);
|
|
ClassDB::bind_method(D_METHOD("get_speed"), &Entity::get_speed);
|
|
ClassDB::bind_method(D_METHOD("get_gcd"), &Entity::get_gcd);
|
|
ClassDB::bind_method(D_METHOD("get_melee_crit"), &Entity::get_melee_crit);
|
|
ClassDB::bind_method(D_METHOD("get_melee_crit_bonus"), &Entity::get_melee_crit_bonus);
|
|
ClassDB::bind_method(D_METHOD("get_spell_crit"), &Entity::get_spell_crit);
|
|
ClassDB::bind_method(D_METHOD("get_spell_crit_bonus"), &Entity::get_spell_crit_bonus);
|
|
ClassDB::bind_method(D_METHOD("get_block"), &Entity::get_block);
|
|
ClassDB::bind_method(D_METHOD("get_parry"), &Entity::get_parry);
|
|
ClassDB::bind_method(D_METHOD("get_damage_reduction"), &Entity::get_damage_reduction);
|
|
ClassDB::bind_method(D_METHOD("get_melee_damage_reduction"), &Entity::get_melee_damage_reduction);
|
|
ClassDB::bind_method(D_METHOD("get_spell_damage_reduction"), &Entity::get_spell_damage_reduction);
|
|
ClassDB::bind_method(D_METHOD("get_damage_taken"), &Entity::get_damage_taken);
|
|
ClassDB::bind_method(D_METHOD("get_melee_damage"), &Entity::get_melee_damage);
|
|
ClassDB::bind_method(D_METHOD("get_spell_damage"), &Entity::get_spell_damage);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_stat_int", "index"), &Entity::get_stat_int);
|
|
ClassDB::bind_method(D_METHOD("set_stat_int", "index", "entry"), &Entity::set_stat_int);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_stat_enum", "index"), &Entity::get_stat_enum);
|
|
ClassDB::bind_method(D_METHOD("set_stat_enum", "stat_id", "entry"), &Entity::set_stat_enum);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_character_skeleton"), &Entity::get_character_skeleton);
|
|
|
|
//// Targeting System ////
|
|
|
|
ClassDB::bind_method(D_METHOD("gets_target"), &Entity::gets_target);
|
|
ClassDB::bind_method(D_METHOD("sets_target", "target"), &Entity::sets_target);
|
|
|
|
ClassDB::bind_method(D_METHOD("getc_target"), &Entity::getc_target);
|
|
ClassDB::bind_method(D_METHOD("setc_target", "target"), &Entity::setc_target);
|
|
}
|