diff --git a/SCsub b/SCsub
index 54bd9d1..0a50867 100644
--- a/SCsub
+++ b/SCsub
@@ -32,6 +32,7 @@ module_env.add_source_files(env.modules_sources,"data/spell.cpp")
 module_env.add_source_files(env.modules_sources,"data/spell/spell_data_constants.cpp")
 
 module_env.add_source_files(env.modules_sources,"entities/stats/stat.cpp")
+module_env.add_source_files(env.modules_sources,"entities/stats/stat_modifier.cpp")
 module_env.add_source_files(env.modules_sources,"entities/stats/stat_data.cpp")
 
 module_env.add_source_files(env.modules_sources,"entities/player_talent.cpp")
diff --git a/data/aura.cpp b/data/aura.cpp
index 2aeefae..ca97f41 100644
--- a/data/aura.cpp
+++ b/data/aura.cpp
@@ -410,6 +410,20 @@ void Aura::sapply(Ref<AuraApplyInfo> info) {
 	call("_sapply", info);
 }
 
+void Aura::sdeapply(Ref<AuraData> info) {
+	ERR_FAIL_COND(!info.is_valid());
+	
+	//always exists
+	call("_sdeapply", info);
+}
+
+void Aura::sadd(Ref<AuraData> aura) {
+	ERR_FAIL_COND(!aura.is_valid());
+
+	//always exists
+	call("_sadd", aura);
+}
+
 void Aura::sremove(Ref<AuraData> aura) {
 	ERR_FAIL_COND(!aura.is_valid());
 
@@ -616,6 +630,19 @@ void Aura::son_category_cooldown_removed(Ref<AuraData> data, Ref<CategoryCooldow
 		call("_son_category_cooldown_removed", data, category_cooldown);
 }
 
+void Aura::son_gcd_started(Ref<AuraData> data, float gcd) {
+	ERR_FAIL_COND(!data.is_valid());
+
+	if (has_method("_son_gcd_started"))
+		call("_son_gcd_started", data, gcd);
+}
+void Aura::son_gcd_finished(Ref<AuraData> data) {
+	ERR_FAIL_COND(!data.is_valid());
+
+	if (has_method("_son_gcd_finished"))
+		call("_son_gcd_finished", data);
+}
+
 void Aura::con_cast_failed(Ref<AuraData> data, Ref<SpellCastInfo> info) {
 	if (has_method("_con_cast_failed"))
 		call("_con_cast_failed", data, info);
@@ -712,6 +739,19 @@ void Aura::con_dealt_heal(Ref<AuraData> data, Ref<SpellHealInfo> info){
 		call("_con_dealt_heal", data, info);
 }
 
+void Aura::con_gcd_started(Ref<AuraData> data, float gcd) {
+	ERR_FAIL_COND(!data.is_valid());
+
+	if (has_method("_con_gcd_started"))
+		call("_con_gcd_started", data, gcd);
+}
+void Aura::con_gcd_finished(Ref<AuraData> data) {
+	ERR_FAIL_COND(!data.is_valid());
+
+	if (has_method("_con_gcd_finished"))
+		call("_con_gcd_finished", data);
+}
+
 void Aura::setup_aura_data(Ref<AuraData> data, Ref<AuraApplyInfo> info) {
 	ERR_FAIL_COND(!data.is_valid() || !info.is_valid());
 
@@ -844,25 +884,44 @@ void Aura::_sapply(Ref<AuraApplyInfo> info) {
 	Ref<AuraData> ad(memnew(AuraData()));
 	setup_aura_data(ad, info);
 
-	info->get_target()->sremove_aura(ad);
-	info->get_target()->sadd_aura(ad);
+	
+}
+
+void Aura::_sdeapply(Ref<AuraData> info) {
+	ERR_FAIL_COND(info->get_owner() == NULL || info->get_caster() == NULL || !info->get_aura().is_valid());
+
+}
+
+void Aura::_sadd(Ref<AuraData> aura) {
+	ERR_FAIL_COND(aura->get_owner() == NULL);
+
+	//sapply(aura);
+	
+	aura->get_owner()->sremove_aura(aura);
+	aura->get_owner()->sadd_aura(aura);
 }
 
 void Aura::_sremove(Ref<AuraData> aura) {
 	ERR_FAIL_COND(aura->get_owner() == NULL);
 
+	sdeapply(aura);
+	
 	aura->get_owner()->sremove_aura(aura);
 }
 
 void Aura::_sremove_expired(Ref<AuraData> aura) {
 	ERR_FAIL_COND(aura->get_owner() == NULL);
 
+	sdeapply(aura);
+	
 	aura->get_owner()->sremove_aura_expired(aura);
 }
 
 void Aura::_sremove_dispell(Ref<AuraData> aura) {
 	ERR_FAIL_COND(aura->get_owner() == NULL);
 
+	sdeapply(aura);
+	
 	aura->get_owner()->sremove_aura_dispelled(aura);
 }
 
@@ -922,18 +981,24 @@ void Aura::_validate_property(PropertyInfo &property) const {
 void Aura::_bind_methods() {
 	//Commands
 	ClassDB::bind_method(D_METHOD("sapply", "info"), &Aura::sapply);
+	ClassDB::bind_method(D_METHOD("sdeapply", "aura"), &Aura::sdeapply);
+	ClassDB::bind_method(D_METHOD("sadd", "aura"), &Aura::sadd);
 	ClassDB::bind_method(D_METHOD("sremove", "aura"), &Aura::sremove);
 	ClassDB::bind_method(D_METHOD("sremove_expired", "aura"), &Aura::sremove_expired);
 	ClassDB::bind_method(D_METHOD("sremove_dispell", "aura"), &Aura::sremove_dispell);
 	ClassDB::bind_method(D_METHOD("supdate", "aura", "delta"), &Aura::supdate);
 
 	BIND_VMETHOD(MethodInfo("_sapply", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "AuraApplyInfo")));
+	BIND_VMETHOD(MethodInfo("_sdeapply", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
+	BIND_VMETHOD(MethodInfo("_sadd", PropertyInfo(Variant::OBJECT, "aura", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
 	BIND_VMETHOD(MethodInfo("_sremove", PropertyInfo(Variant::OBJECT, "aura", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
 	BIND_VMETHOD(MethodInfo("_sremove_expired", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
 	BIND_VMETHOD(MethodInfo("_sremove_dispell", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
 	BIND_VMETHOD(MethodInfo("_supdate", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::REAL, "delta")));
 
 	ClassDB::bind_method(D_METHOD("_sapply", "info"), &Aura::_sapply);
+	ClassDB::bind_method(D_METHOD("_sdeapply", "aura"), &Aura::_sdeapply);
+	ClassDB::bind_method(D_METHOD("_sadd", "aura"), &Aura::_sadd);
 	ClassDB::bind_method(D_METHOD("_sremove", "aura"), &Aura::_sremove);
 	ClassDB::bind_method(D_METHOD("_sremove_expired", "aura"), &Aura::_sremove_expired);
 	ClassDB::bind_method(D_METHOD("_sremove_dispell", "aura"), &Aura::_sremove_dispell);
@@ -974,6 +1039,9 @@ void Aura::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("son_category_cooldown_added", "data", "category_cooldown"), &Aura::son_category_cooldown_added);
 	ClassDB::bind_method(D_METHOD("son_category_cooldown_removed", "data", "category_cooldown"), &Aura::son_category_cooldown_removed);
 	
+	ClassDB::bind_method(D_METHOD("son_gcd_started", "data", "gcd"), &Aura::son_gcd_started);
+	ClassDB::bind_method(D_METHOD("son_gcd_finished", "data"), &Aura::son_gcd_finished);
+	
 	BIND_VMETHOD(MethodInfo("_son_before_cast", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
 	BIND_VMETHOD(MethodInfo("_son_before_cast_target", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
 	BIND_VMETHOD(MethodInfo("_son_cast_started", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
@@ -1007,6 +1075,9 @@ void Aura::_bind_methods() {
 	BIND_VMETHOD(MethodInfo("_son_category_cooldown_added", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "category_cooldown", PROPERTY_HINT_RESOURCE_TYPE, "CategoryCooldown")));
 	BIND_VMETHOD(MethodInfo("_son_category_cooldown_removed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "category_cooldown", PROPERTY_HINT_RESOURCE_TYPE, "CategoryCooldown")));
 
+	BIND_VMETHOD(MethodInfo("_son_gcd_started", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::REAL, "gcd")));
+	BIND_VMETHOD(MethodInfo("_son_gcd_finished", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
+
 	//Clientside Event Handlers
 	ClassDB::bind_method(D_METHOD("con_cast_failed", "data", "info"), &Aura::con_cast_failed);
 	ClassDB::bind_method(D_METHOD("con_cast_started", "data", "info"), &Aura::con_cast_started);
@@ -1029,7 +1100,10 @@ void Aura::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("con_dealt_damage", "data", "info"), &Aura::con_dealt_damage);
 	ClassDB::bind_method(D_METHOD("con_heal_dealt", "data", "info"), &Aura::con_heal_dealt);
 	ClassDB::bind_method(D_METHOD("con_dealt_heal", "data", "info"), &Aura::con_dealt_heal);
-    
+	
+	ClassDB::bind_method(D_METHOD("con_gcd_started", "data", "info"), &Aura::con_gcd_started);
+	ClassDB::bind_method(D_METHOD("con_gcd_finished", "data"), &Aura::con_gcd_finished);
+	
 	BIND_VMETHOD(MethodInfo("_con_cast_failed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
 	BIND_VMETHOD(MethodInfo("_con_cast_started", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
 	BIND_VMETHOD(MethodInfo("_con_cast_state_changed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
@@ -1052,6 +1126,9 @@ void Aura::_bind_methods() {
 	BIND_VMETHOD(MethodInfo("_con_heal_dealt", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo")));
 	BIND_VMETHOD(MethodInfo("_con_dealt_heal", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo")));
 	
+	BIND_VMETHOD(MethodInfo("_con_gcd_started", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData"), PropertyInfo(Variant::REAL, "gcd")));
+	BIND_VMETHOD(MethodInfo("_con_gcd_finished", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
+	
 	//Calculations / Queries
 	ClassDB::bind_method(D_METHOD("setup_aura_data", "data", "info"), &Aura::setup_aura_data);
 
@@ -1223,18 +1300,18 @@ void Aura::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_heal_scaling_curve", "curve"), &Aura::set_heal_scaling_curve);
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "heal_scaling_curve", PROPERTY_HINT_RESOURCE_TYPE, "Curve"), "set_heal_scaling_curve", "get_heal_scaling_curve");
 
-	//ADD_GROUP("States", "states"); not needed
+	ADD_GROUP("States", "states");
 	ClassDB::bind_method(D_METHOD("get_add_states"), &Aura::get_add_states);
 	ClassDB::bind_method(D_METHOD("set_add_states", "value"), &Aura::set_add_states);
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "states/add_states", PROPERTY_HINT_FLAGS, EntityEnums::BINDING_STRING_ENTITY_STATE_TYPES), "set_add_states", "get_add_states");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "states_add", PROPERTY_HINT_FLAGS, EntityEnums::BINDING_STRING_ENTITY_STATE_TYPES), "set_add_states", "get_add_states");
 
 	ClassDB::bind_method(D_METHOD("get_remove_effects_with_states"), &Aura::get_remove_effects_with_states);
 	ClassDB::bind_method(D_METHOD("set_remove_effects_with_states", "value"), &Aura::set_remove_effects_with_states);
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "states/remove_effects_with_states", PROPERTY_HINT_FLAGS, EntityEnums::BINDING_STRING_ENTITY_STATE_TYPES), "set_remove_effects_with_states", "get_remove_effects_with_states");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "states_remove_effects", PROPERTY_HINT_FLAGS, EntityEnums::BINDING_STRING_ENTITY_STATE_TYPES), "set_remove_effects_with_states", "get_remove_effects_with_states");
 
 	ClassDB::bind_method(D_METHOD("get_supress_states"), &Aura::get_supress_states);
 	ClassDB::bind_method(D_METHOD("set_supress_states", "value"), &Aura::set_supress_states);
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "states/supress_states", PROPERTY_HINT_FLAGS, EntityEnums::BINDING_STRING_ENTITY_STATE_TYPES), "set_supress_states", "get_supress_states");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "states_supress", PROPERTY_HINT_FLAGS, EntityEnums::BINDING_STRING_ENTITY_STATE_TYPES), "set_supress_states", "get_supress_states");
 
 	////    Triggers    ////
 	ADD_GROUP("Triggers", "trigger");
@@ -1253,9 +1330,9 @@ void Aura::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "trigger_count", PROPERTY_HINT_RANGE, "0," + itos(MAX_TRIGGER_DATA), PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), "set_trigger_count", "get_trigger_count");
 
 	for (int i = 0; i < MAX_TRIGGER_DATA; i++) {
-		ADD_PROPERTYI(PropertyInfo(Variant::INT, "Trigger_" + itos(i) + "/trigger_event", PROPERTY_HINT_ENUM, SpellEnums::BINDING_STRING_TRIGGER_EVENTS, PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_INTERNAL), "set_trigger_event", "get_trigger_event", i);
-		ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "Trigger_" + itos(i) + "/trigger_aura", PROPERTY_HINT_RESOURCE_TYPE, "Aura", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_INTERNAL), "set_trigger_aura", "get_trigger_aura", i);
-		ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "Trigger_" + itos(i) + "/trigger_spell", PROPERTY_HINT_RESOURCE_TYPE, "Spell", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_INTERNAL), "set_trigger_spell", "get_trigger_spell", i);
+		ADD_PROPERTYI(PropertyInfo(Variant::INT, "Trigger_" + itos(i) + "/event", PROPERTY_HINT_ENUM, SpellEnums::BINDING_STRING_TRIGGER_EVENTS, PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_INTERNAL), "set_trigger_event", "get_trigger_event", i);
+		ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "Trigger_" + itos(i) + "/aura", PROPERTY_HINT_RESOURCE_TYPE, "Aura", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_INTERNAL), "set_trigger_aura", "get_trigger_aura", i);
+		ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "Trigger_" + itos(i) + "/spell", PROPERTY_HINT_RESOURCE_TYPE, "Spell", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_INTERNAL), "set_trigger_spell", "get_trigger_spell", i);
 	}
 
 	ADD_GROUP("Attributes", "attribute");
diff --git a/data/aura.h b/data/aura.h
index 9fb0f64..74fa2c6 100644
--- a/data/aura.h
+++ b/data/aura.h
@@ -197,12 +197,16 @@ public:
 
 	//Commands
 	void sapply(Ref<AuraApplyInfo> info);
+	void sdeapply(Ref<AuraData> info);
+	void sadd(Ref<AuraData> aura);
 	void sremove(Ref<AuraData> aura);
 	void sremove_expired(Ref<AuraData> aura);
 	void sremove_dispell(Ref<AuraData> aura);
 	void supdate(Ref<AuraData> aura, float delta);
 
 	virtual void _sapply(Ref<AuraApplyInfo> info);
+	virtual void _sdeapply(Ref<AuraData> info);
+	virtual void _sadd(Ref<AuraData> aura);
 	virtual void _sremove(Ref<AuraData> aura);
 	virtual void _sremove_expired(Ref<AuraData> aura);
 	virtual void _supdate(Ref<AuraData> aura, float delta);
@@ -243,6 +247,9 @@ public:
 	void son_category_cooldown_added(Ref<AuraData> data, Ref<CategoryCooldown> category_cooldown);
 	void son_category_cooldown_removed(Ref<AuraData> data, Ref<CategoryCooldown> category_cooldown);
 
+	void son_gcd_started(Ref<AuraData> data, float gcd);
+	void son_gcd_finished(Ref<AuraData> data);
+	
 	//Clientside Event Handlers
 	void con_cast_failed(Ref<AuraData> data, Ref<SpellCastInfo> info);
 	void con_cast_started(Ref<AuraData> data, Ref<SpellCastInfo> info);
@@ -265,6 +272,9 @@ public:
 	void con_dealt_damage(Ref<AuraData> data, Ref<SpellDamageInfo> info);
 	void con_heal_dealt(Ref<AuraData> data, Ref<SpellHealInfo> info);
 	void con_dealt_heal(Ref<AuraData> data, Ref<SpellHealInfo> info);
+	
+	void con_gcd_started(Ref<AuraData> data, float gcd);
+	void con_gcd_finished(Ref<AuraData> data);
     
 	//Calculations / Queries
 	void setup_aura_data(Ref<AuraData> data, Ref<AuraApplyInfo> info);
diff --git a/data/aura_stat_attribute.h b/data/aura_stat_attribute.h
index ada197f..6908003 100644
--- a/data/aura_stat_attribute.h
+++ b/data/aura_stat_attribute.h
@@ -28,7 +28,7 @@ public:
 	}
 
 protected:
-	static void _bind_method() {
+	static void _bind_methods() {
 		ClassDB::bind_method(D_METHOD("get_stat"), &AuraStatAttribute::get_stat);
 		ClassDB::bind_method(D_METHOD("set_stat", "value"), &AuraStatAttribute::set_stat);
 		ADD_PROPERTY(PropertyInfo(Variant::INT, "stat", PROPERTY_HINT_ENUM, Stat::STAT_BINDING_STRING), "set_stat", "get_stat");
@@ -53,4 +53,4 @@ private:
 	float _percent_mod;
 };
 
- #endif
\ No newline at end of file
+ #endif
diff --git a/data/character_class.cpp b/data/character_class.cpp
index c62bf7f..c191412 100644
--- a/data/character_class.cpp
+++ b/data/character_class.cpp
@@ -302,6 +302,33 @@ void CharacterClass::son_category_cooldown_removed(Ref<CategoryCooldown> categor
 		call("_son_category_cooldown_removed", category_cooldown);
 }
 
+void CharacterClass::son_gcd_started(Entity *entity, float gcd) {
+	if (has_method("_son_gcd_started"))
+		call("_son_gcd_started", entity, gcd);
+}
+void CharacterClass::son_gcd_finished(Entity *entity) {
+	if (has_method("_son_gcd_finished"))
+		call("_son_gcd_finished", entity);
+}
+void CharacterClass::son_gcd_started_bind(Node *entity, float gcd) {
+	ERR_FAIL_COND(entity == NULL);
+
+	Entity *e = Object::cast_to<Entity>(entity);
+
+	ERR_FAIL_COND(e == NULL);
+
+	son_gcd_started(e, gcd);
+}
+void CharacterClass::son_gcd_finished_bind(Node *entity) {
+	ERR_FAIL_COND(entity == NULL);
+
+	Entity *e = Object::cast_to<Entity>(entity);
+
+	ERR_FAIL_COND(e == NULL);
+
+	son_gcd_finished(e);
+}
+
 //Clientside Event Handlers
 void CharacterClass::con_cast_failed(Ref<SpellCastInfo> info) {
 	ERR_FAIL_COND(!info.is_valid());
@@ -425,6 +452,33 @@ void CharacterClass::con_dealt_heal(Ref<SpellHealInfo> info) {
 		call("_con_dealt_heal", info);
 }
 
+void CharacterClass::con_gcd_started(Entity *entity, float gcd) {
+	if (has_method("_con_gcd_started"))
+		call("_con_gcd_started", entity, gcd);
+}
+void CharacterClass::con_gcd_finished(Entity *entity) {
+	if (has_method("_con_gcd_finished"))
+		call("_con_gcd_finished", entity);
+}
+void CharacterClass::con_gcd_started_bind(Node *entity, float gcd) {
+	ERR_FAIL_COND(entity == NULL);
+
+	Entity *e = Object::cast_to<Entity>(entity);
+
+	ERR_FAIL_COND(e == NULL);
+
+	con_gcd_started(e, gcd);
+}
+void CharacterClass::con_gcd_finished_bind(Node *entity) {
+	ERR_FAIL_COND(entity == NULL);
+
+	Entity *e = Object::cast_to<Entity>(entity);
+
+	ERR_FAIL_COND(e == NULL);
+
+	con_gcd_finished(e);
+}
+
 
 void CharacterClass::sai_follow(Entity *entity) {
 	ERR_FAIL_COND(entity == NULL);
@@ -544,6 +598,9 @@ void CharacterClass::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("son_category_cooldown_added", "category_cooldown"), &CharacterClass::son_category_cooldown_added);
 	ClassDB::bind_method(D_METHOD("son_category_cooldown_removed", "category_cooldown"), &CharacterClass::son_category_cooldown_removed);
 	
+	ClassDB::bind_method(D_METHOD("son_gcd_started", "entity", "gcd"), &CharacterClass::son_gcd_started_bind);
+	ClassDB::bind_method(D_METHOD("son_gcd_finished", "entity"), &CharacterClass::son_gcd_finished_bind);
+	
 	BIND_VMETHOD(MethodInfo("_son_before_cast", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
 	BIND_VMETHOD(MethodInfo("_son_before_cast_target", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
 	BIND_VMETHOD(MethodInfo("_son_cast_started", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
@@ -579,6 +636,8 @@ void CharacterClass::_bind_methods() {
 	BIND_VMETHOD(MethodInfo("_son_category_cooldown_added", PropertyInfo(Variant::OBJECT, "category_cooldown", PROPERTY_HINT_RESOURCE_TYPE, "CategoryCooldown")));
 	BIND_VMETHOD(MethodInfo("_son_category_cooldown_removed", PropertyInfo(Variant::OBJECT, "category_cooldown", PROPERTY_HINT_RESOURCE_TYPE, "CategoryCooldown")));
 
+	BIND_VMETHOD(MethodInfo("_son_gcd_started", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::REAL, "gcd")));
+	BIND_VMETHOD(MethodInfo("_son_gcd_finished", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity")));
     
     //Clientside Event Handlers
 	ClassDB::bind_method(D_METHOD("con_cast_failed", "info"), &CharacterClass::con_cast_failed);
@@ -597,6 +656,9 @@ void CharacterClass::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("con_aura_added", "data"), &CharacterClass::con_aura_added);
 	ClassDB::bind_method(D_METHOD("con_aura_removed", "data"), &CharacterClass::con_aura_removed);
 	ClassDB::bind_method(D_METHOD("con_aura_refresh", "data"), &CharacterClass::con_aura_refresh);
+	
+	ClassDB::bind_method(D_METHOD("con_gcd_started", "entity", "gcd"), &CharacterClass::con_gcd_started_bind);
+	ClassDB::bind_method(D_METHOD("con_gcd_finished", "entity"), &CharacterClass::con_gcd_finished_bind);
 
 	BIND_VMETHOD(MethodInfo("_con_cast_failed", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
 	BIND_VMETHOD(MethodInfo("_con_cast_started", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
@@ -615,6 +677,9 @@ void CharacterClass::_bind_methods() {
 	BIND_VMETHOD(MethodInfo("_con_aura_removed", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
 	BIND_VMETHOD(MethodInfo("_con_aura_refresh", PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "AuraData")));
     
+	BIND_VMETHOD(MethodInfo("_con_gcd_started", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::REAL, "gcd")));
+	BIND_VMETHOD(MethodInfo("_con_gcd_finished", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity")));
+	
 	ClassDB::bind_method(D_METHOD("sai_follow", "entity"), &CharacterClass::sai_follow_bind);
 	ClassDB::bind_method(D_METHOD("sai_rest", "entity"), &CharacterClass::sai_rest_bind);
 	ClassDB::bind_method(D_METHOD("sai_regenerate", "entity"), &CharacterClass::sai_regenerate_bind);
diff --git a/data/character_class.h b/data/character_class.h
index 2be8f87..79abae4 100644
--- a/data/character_class.h
+++ b/data/character_class.h
@@ -121,6 +121,11 @@ public:
 	void son_category_cooldown_added(Ref<CategoryCooldown> category_cooldown);
 	void son_category_cooldown_removed(Ref<CategoryCooldown> category_cooldown);
 	
+	void son_gcd_started(Entity *entity, float gcd);
+	void son_gcd_finished(Entity *entity);
+	void son_gcd_started_bind(Node *entity, float gcd);
+	void son_gcd_finished_bind(Node *entity);
+	
     //Clientside Event Handlers
 	void con_cast_failed(Ref<SpellCastInfo> info);
 	void con_cast_started(Ref<SpellCastInfo> info);
@@ -144,6 +149,11 @@ public:
 	void con_dealt_damage(Ref<SpellDamageInfo> info);
 	void con_heal_dealt(Ref<SpellHealInfo> info);
 	void con_dealt_heal(Ref<SpellHealInfo> info);
+	
+	void con_gcd_started(Entity *entity, float gcd);
+	void con_gcd_finished(Entity *entity);
+	void con_gcd_started_bind(Node *entity, float gcd);
+	void con_gcd_finished_bind(Node *entity);
     
     //    AI    //
 	void sai_follow(Entity *entity);
diff --git a/data/spell.cpp b/data/spell.cpp
index 5e9d026..12e97f3 100644
--- a/data/spell.cpp
+++ b/data/spell.cpp
@@ -749,7 +749,7 @@ Spell::Spell() {
 	_cost_resource = 0;
 	//PlayerResourceTypes _give_resource_type;
 	_give_resource = 0;
-	_has_global_cooldown = false;
+	_has_global_cooldown = true;
 	_is_local_spell = false;
 
 	//String _name_key;
diff --git a/entities/entity.cpp b/entities/entity.cpp
index 732ae0a..2d456c5 100644
--- a/entities/entity.cpp
+++ b/entities/entity.cpp
@@ -172,24 +172,6 @@ void Entity::sets_character_class(Ref<CharacterClass> value) {
 	//SEND_RPC(rpc("setc_character_class", 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;
-}
-
 Entity::Entity() {
 	_s_guid = 0;
 	_c_guid = 0;
@@ -233,21 +215,6 @@ Entity::Entity() {
 	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_active_category_cooldowns = 0;
 	_c_active_category_cooldowns = 0;
     
@@ -309,14 +276,6 @@ Entity::Entity() {
 	SET_RPC_REMOTE("setc_level");
 	SET_RPC_REMOTE("setc_xp");
 
-	////    SpellCastData    ////
-
-	//SET_RPC_PUPPET("setc_casting");
-	//SET_RPC_PUPPET("setc_spell_id");
-	//SET_RPC_PUPPET("setc_current_cast_time");
-	//SET_RPC_PUPPET("setc_cast_time");
-	//SET_RPC_PUPPET("setc_spell_target");
-
 	////     Stats    ////
 
 	//send stats
@@ -486,12 +445,20 @@ bool Entity::gets_global_cooldown() {
 
 void Entity::sstart_global_cooldown(float value) {
 	_s_gcd = value;
-
+	
+	void son_gcd_started();
+	
+	emit_signal("sgcd_started", _s_gcd);
+				
 	SEND_RPC(rpc("cstart_global_cooldown", value), cstart_global_cooldown(value));
 }
 
 void Entity::cstart_global_cooldown(float value) {
 	_c_gcd = value;
+
+	void con_gcd_started();
+	
+	emit_signal("cgcd_started", _c_gcd);
 }
 
 ////    States    ////
@@ -1206,6 +1173,62 @@ void Entity::son_category_cooldown_removed(Ref<CategoryCooldown> category_cooldo
 	}
 }
 
+void Entity::son_gcd_started() {
+    if (_s_character_class.is_valid()) {
+        _s_character_class->son_gcd_started(this, _s_gcd);
+    }
+    
+    if (has_method("_son_gcd_started"))
+		call("_son_gcd_started", _s_gcd);
+    
+	for (int i = 0; i < _s_auras.size(); ++i) {
+		Ref<AuraData> ad = _s_auras.get(i);
+
+		ad->get_aura()->son_gcd_started(ad, _s_gcd);
+	}
+}
+void Entity::son_gcd_finished() {
+	if (_s_character_class.is_valid()) {
+        _s_character_class->son_gcd_finished(this);
+    }
+    
+    if (has_method("_son_gcd_finished"))
+		call("_son_gcd_finished");
+    
+	for (int i = 0; i < _s_auras.size(); ++i) {
+		Ref<AuraData> ad = _s_auras.get(i);
+
+		ad->get_aura()->son_gcd_finished(ad);
+	}
+}
+void Entity::con_gcd_started() {
+	if (_s_character_class.is_valid()) {
+        _s_character_class->con_gcd_started(this, _c_gcd);
+    }
+    
+    if (has_method("_con_gcd_started"))
+		call("_con_gcd_started", _c_gcd);
+    
+	for (int i = 0; i < _s_auras.size(); ++i) {
+		Ref<AuraData> ad = _s_auras.get(i);
+
+		ad->get_aura()->con_gcd_started(ad, _c_gcd);
+	}
+}
+void Entity::con_gcd_finished() {
+	if (_s_character_class.is_valid()) {
+        _s_character_class->con_gcd_finished(this);
+    }
+    
+    if (has_method("_con_gcd_finished"))
+		call("_con_gcd_finished");
+    
+	for (int i = 0; i < _s_auras.size(); ++i) {
+		Ref<AuraData> ad = _s_auras.get(i);
+
+		ad->get_aura()->con_gcd_finished(ad);
+	}
+}
 
 void Entity::sadd_aura(Ref<AuraData> aura) {
 	ERR_FAIL_COND(!aura.is_valid());
@@ -1444,6 +1467,31 @@ Ref<AuraData> Entity::sget_aura(int index) {
 	return Ref<AuraData>(_s_auras.get(index));
 }
 
+Ref<AuraData> Entity::sget_aura_by(Entity *caster, int aura_id) {
+	for (int i = 0; i < _s_auras.size(); ++i) {
+		Ref<AuraData> ad = _s_auras.get(i);
+		
+		if (ad->get_aura_id() == aura_id && ad->get_caster() == caster) {
+			return ad;
+		}
+	}
+	
+	return Ref<AuraData>(NULL);
+}
+Ref<AuraData> Entity::sget_aura_by_bind(Node *caster, int aura_id) {
+	if (!caster) {
+		return Ref<AuraData>(NULL);
+	}
+
+	Entity *e = cast_to<Entity>(caster);
+
+	if (!e) {
+		return Ref<AuraData>(NULL);
+	}
+
+	return sget_aura_by(e, aura_id);
+}
+
 int Entity::cget_aura_count() {
 	return _s_auras.size();
 }
@@ -2179,6 +2227,16 @@ int Entity::getc_category_cooldown_count() {
 	return _c_category_cooldowns.size();
 }
 
+
+////    Casting System    ////
+
+bool Entity::sis_casting() {
+	return _s_spell_cast_info.is_valid();
+}
+bool Entity::cis_casting() {
+	return _c_spell_cast_info.is_valid();
+}
+
 Ref<SpellCastInfo> Entity::gets_spell_cast_info() {
 	return Ref<SpellCastInfo>(_s_spell_cast_info);
 }
@@ -2539,85 +2597,6 @@ void Entity::rpc_level_up() {
        }*/
 }
 
-////    SpellCastData    ////
-
-bool Entity::gets_casting() {
-	return _s_casting;
-}
-void Entity::sets_casting(bool value) {
-	_s_casting = value;
-}
-
-int Entity::gets_spell_id() {
-	return _s_spell_id;
-}
-void Entity::sets_spell_id(int value) {
-	_s_spell_id = value;
-}
-
-float Entity::gets_current_cast_time() {
-	return _s_current_cast_time;
-}
-void Entity::sets_current_cast_time(float value) {
-	_s_current_cast_time = value;
-}
-
-float Entity::gets_cast_time() {
-	return _s_cast_time;
-}
-void Entity::sets_cast_time(float value) {
-	_s_cast_time = value;
-}
-
-float Entity::gets_spell_scale() {
-	return _s_spell_scale;
-}
-void Entity::sets_spell_scale(float value) {
-	_s_spell_scale = value;
-}
-
-bool Entity::getc_casting() {
-	return _c_casting;
-}
-void Entity::setc_casting(bool value) {
-	_c_casting = value;
-}
-
-int Entity::getc_spell_id() {
-	return _c_spell_id;
-}
-void Entity::setc_spell_id(int value) {
-	_c_spell_id = value;
-}
-
-float Entity::getc_current_cast_time() {
-	return _c_current_cast_time;
-}
-void Entity::setc_current_cast_time(float value) {
-	_c_current_cast_time = value;
-}
-
-float Entity::getc_cast_time() {
-	return _c_cast_time;
-}
-void Entity::setc_cast_time(float value) {
-	_c_cast_time = value;
-}
-
-String Entity::getc_spell_name() {
-	return _c_spell_name;
-}
-void Entity::setc_spell_name(String value) {
-	_c_spell_name = value;
-}
-
-int Entity::gets_target_guid() {
-	return _s_target_guid;
-}
-int Entity::gets_spell_cast_game_object_guid() {
-	return _s_spell_cast_game_object_guid;
-}
-
 void Entity::update(float delta) {
 	if (_s_gcd > 0.0000001) {
 		_s_gcd -= delta;
@@ -2625,6 +2604,9 @@ void Entity::update(float delta) {
 		if (_s_gcd <= 0) {
 			_s_gcd = 0;
 
+				
+			void son_gcd_finished();
+
 			emit_signal("sgcd_finished");
 		}
 	}
@@ -2634,6 +2616,8 @@ void Entity::update(float delta) {
 
 		if (_c_gcd <= 0) {
 			_c_gcd = 0;
+			
+			void con_gcd_finished();
 
 			emit_signal("cgcd_finished");
 		}
@@ -2733,16 +2717,21 @@ void Entity::_bind_methods() {
 	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_received", 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_received", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "damage_pipeline_data", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo")));
+	ADD_SIGNAL(MethodInfo("son_damage_received", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo")));
+	ADD_SIGNAL(MethodInfo("con_damage_received", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "info", 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("con_dealt_damage", 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, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo")));
+	ADD_SIGNAL(MethodInfo("con_dealt_damage", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellDamageInfo")));
 
-	ADD_SIGNAL(MethodInfo("son_heal_received", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "damage_pipeline_data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo")));
-	ADD_SIGNAL(MethodInfo("con_heal_received", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "damage_pipeline_data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo")));
+	ADD_SIGNAL(MethodInfo("son_heal_received", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo")));
+	ADD_SIGNAL(MethodInfo("con_heal_received", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo")));
 
-	ADD_SIGNAL(MethodInfo("con_dealt_heal", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "damage_pipeline_data", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo")));
+	ADD_SIGNAL(MethodInfo("con_dealt_heal", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo")));
+	
+	ADD_SIGNAL(MethodInfo("con_heal_dealt", PropertyInfo(Variant::OBJECT, "Entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo")));
+	
+	
+	
 
 	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")));
@@ -2804,6 +2793,9 @@ void Entity::_bind_methods() {
     
     BIND_VMETHOD(MethodInfo("_son_death"));
 	
+	BIND_VMETHOD(MethodInfo("_son_gcd_started", PropertyInfo(Variant::REAL, "gcd")));
+	BIND_VMETHOD(MethodInfo("_son_gcd_finished"));
+	
 	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);
 
@@ -2826,7 +2818,10 @@ void Entity::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("son_cast_failed", "info"), &Entity::son_cast_failed);
     
     ClassDB::bind_method(D_METHOD("son_death"), &Entity::son_death);
-    
+	
+	ClassDB::bind_method(D_METHOD("son_gcd_started"), &Entity::son_gcd_started);
+	ClassDB::bind_method(D_METHOD("son_gcd_finished"), &Entity::son_gcd_finished);
+	
 	//Clientside EventHandlers
 	BIND_VMETHOD(MethodInfo("_con_cast_failed", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
 	BIND_VMETHOD(MethodInfo("_con_cast_started", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo")));
@@ -2850,6 +2845,9 @@ void Entity::_bind_methods() {
 	BIND_VMETHOD(MethodInfo("_con_heal_dealt", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo")));
 	BIND_VMETHOD(MethodInfo("_con_dealt_heal", PropertyInfo(Variant::OBJECT, "info", PROPERTY_HINT_RESOURCE_TYPE, "SpellHealInfo")));
 	
+	BIND_VMETHOD(MethodInfo("_con_gcd_started", PropertyInfo(Variant::REAL, "gcd")));
+	BIND_VMETHOD(MethodInfo("_con_gcd_finished"));
+	
 	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);
@@ -2871,6 +2869,9 @@ void Entity::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("con_dealt_damage", "info"), &Entity::con_dealt_damage);
 	ClassDB::bind_method(D_METHOD("con_heal_dealt", "info"), &Entity::con_heal_dealt);
 	ClassDB::bind_method(D_METHOD("con_dealt_heal", "info"), &Entity::con_dealt_heal);
+	
+	ClassDB::bind_method(D_METHOD("con_gcd_started"), &Entity::con_gcd_started);
+	ClassDB::bind_method(D_METHOD("con_gcd_finished"), &Entity::con_gcd_finished);
     
 	//Modifiers/Requesters
 	ClassDB::bind_method(D_METHOD("sapply_passives_damage_receive", "data"), &Entity::sapply_passives_damage_receive);
@@ -2907,7 +2908,8 @@ void Entity::_bind_methods() {
 
 	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("sget_aura_by", "caster", "aura_id"), &Entity::sget_aura_by_bind);
+	
 	ClassDB::bind_method(D_METHOD("cget_aura_count"), &Entity::cget_aura_count);
 	ClassDB::bind_method(D_METHOD("cget_aura", "index"), &Entity::cget_aura);
 
@@ -2997,7 +2999,6 @@ void Entity::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_stat_enum", "stat_id", "entry"), &Entity::set_stat_enum);
 
 	//Resources
-
 	ClassDB::bind_method(D_METHOD("gets_resource", "index"), &Entity::gets_resource);
 	ClassDB::bind_method(D_METHOD("adds_resource", "palyer_resource"), &Entity::adds_resource);
 	ClassDB::bind_method(D_METHOD("gets_resource_count"), &Entity::gets_resource_count);
@@ -3010,9 +3011,9 @@ void Entity::_bind_methods() {
 
 	//GCD
 	ADD_SIGNAL(MethodInfo("sgcd_started", PropertyInfo(Variant::REAL, "value")));
-	ADD_SIGNAL(MethodInfo("sgcd_finished", PropertyInfo(Variant::REAL, "value")));
+	ADD_SIGNAL(MethodInfo("sgcd_finished"));
 	ADD_SIGNAL(MethodInfo("cgcd_started", PropertyInfo(Variant::REAL, "value")));
-	ADD_SIGNAL(MethodInfo("cgcd_finished", PropertyInfo(Variant::REAL, "value")));
+	ADD_SIGNAL(MethodInfo("cgcd_finished"));
 
 	ClassDB::bind_method(D_METHOD("getc_has_global_cooldown"), &Entity::getc_has_global_cooldown);
 	ClassDB::bind_method(D_METHOD("gets_has_global_cooldown"), &Entity::gets_has_global_cooldown);
@@ -3034,6 +3035,9 @@ void Entity::_bind_methods() {
 
 	//Casting System
 
+	ClassDB::bind_method(D_METHOD("sis_casting"), &Entity::sis_casting);
+	ClassDB::bind_method(D_METHOD("cis_casting"), &Entity::cis_casting);
+
 	ClassDB::bind_method(D_METHOD("gets_spell_cast_info"), &Entity::gets_spell_cast_info);
 	ClassDB::bind_method(D_METHOD("sets_spell_cast_info", "value"), &Entity::sets_spell_cast_info);
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "sspell_cast_info", PROPERTY_HINT_RESOURCE_TYPE, "SpellCastInfo"), "sets_spell_cast_info", "gets_spell_cast_info");
@@ -3099,10 +3103,6 @@ void Entity::_bind_methods() {
 
 	////    Targeting System    ////
 
-	ClassDB::bind_method(D_METHOD("gets_spell_target"), &Entity::gets_spell_target);
-	ClassDB::bind_method(D_METHOD("sets_spell_target", "target"), &Entity::sets_spell_target);
-	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "sspell_target", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), "sets_spell_target", "gets_spell_target");
-
 	ClassDB::bind_method(D_METHOD("crequest_target_change", "path"), &Entity::crequest_target_change);
 	ClassDB::bind_method(D_METHOD("net_sets_target", "path"), &Entity::net_sets_target);
 	ClassDB::bind_method(D_METHOD("net_setc_target", "path"), &Entity::net_setc_target);
diff --git a/entities/entity.h b/entities/entity.h
index 39fed67..13c4bc6 100644
--- a/entities/entity.h
+++ b/entities/entity.h
@@ -195,44 +195,6 @@ public:
 	void rpc_level_up();
 	void registers();
 
-	////    SpellCastData    ////
-
-	bool gets_casting();
-	void sets_casting(bool value);
-
-	int gets_spell_id();
-	void sets_spell_id(int value);
-
-	float gets_current_cast_time();
-	void sets_current_cast_time(float value);
-
-	float gets_cast_time();
-	void sets_cast_time(float value);
-
-	float gets_spell_scale();
-	void sets_spell_scale(float value);
-
-	bool getc_casting();
-	void setc_casting(bool value);
-
-	int getc_spell_id();
-	void setc_spell_id(int value);
-
-	float getc_current_cast_time();
-	void setc_current_cast_time(float value);
-
-	float getc_cast_time();
-	void setc_cast_time(float value);
-
-	String getc_spell_name();
-	void setc_spell_name(String value);
-
-	Entity *gets_spell_target();
-	void sets_spell_target(Node *p_target);
-
-	int gets_target_guid();
-	int gets_spell_cast_game_object_guid();
-
 	////     Stats    ////
 
 	_FORCE_INLINE_ Ref<Stat> get_health() { return _health; }
@@ -326,6 +288,11 @@ public:
 	void son_category_cooldown_added(Ref<CategoryCooldown> category_cooldown);
 	void son_category_cooldown_removed(Ref<CategoryCooldown> category_cooldown);
 	
+	void son_gcd_started();
+	void son_gcd_finished();
+	void con_gcd_started();
+	void con_gcd_finished();
+	
 	//Clientside EventHandlers
 	void con_cast_failed(Ref<SpellCastInfo> info);
 	void con_cast_started(Ref<SpellCastInfo> info);
@@ -385,9 +352,12 @@ public:
 
 	void sremove_auras_with_group(int aura_group);
 
+	//NOTE: No reason for shas_aura_by, just query it, and check for null.
 	int sget_aura_count();
 	Ref<AuraData> sget_aura(int index);
-
+	Ref<AuraData> sget_aura_by(Entity *caster, int aura_id);
+	Ref<AuraData> sget_aura_by_bind(Node *caster, int aura_id);
+	
 	int cget_aura_count();
 	Ref<AuraData> cget_aura(int index);
 
@@ -405,6 +375,9 @@ public:
 	bool getc_is_dead();
 
 	////    Casting System    ////
+	
+	bool sis_casting();
+	bool cis_casting();
 
 	Ref<SpellCastInfo> gets_spell_cast_info();
 	void sets_spell_cast_info(Ref<SpellCastInfo> info);
@@ -614,21 +587,6 @@ private:
 
 	////    SpellCastData    ////
 
-	bool _s_casting;
-	int _s_spell_id;
-	float _s_current_cast_time;
-	float _s_cast_time;
-	float _s_spell_scale;
-	bool _c_casting;
-	int _c_spell_id;
-	float _c_current_cast_time;
-	float _c_cast_time;
-	String _c_spell_name;
-	Entity *_s_spell_target;
-	Entity *_c_spell_target;
-	int _s_spell_target_guid;
-	int _s_spell_cast_game_object_guid;
-
 	Ref<SpellCastInfo> _s_spell_cast_info;
 	Ref<SpellCastInfo> _c_spell_cast_info;
 
diff --git a/entities/stats/stat.cpp b/entities/stats/stat.cpp
index aa2d100..f4cdad9 100644
--- a/entities/stats/stat.cpp
+++ b/entities/stats/stat.cpp
@@ -15,7 +15,6 @@ Stat::Stat() {
 	_c_max = (float)(0);
 	_c_current = (float)(0);
 
-	_disabled = false;
 	_modifier_apply_type = MODIFIER_APPLY_TYPE_STANDARD;
 }
 
@@ -30,7 +29,6 @@ Stat::Stat(Stat::StatId id) {
 	_c_max = (float)(0);
 	_c_current = (float)(0);
 
-	_disabled = false;
 	_modifier_apply_type = MODIFIER_APPLY_TYPE_STANDARD;
 }
 
@@ -45,7 +43,6 @@ Stat::Stat(Stat::StatId id, StatModifierApplyType modifier_apply_type) {
 	_c_max = (float)(0);
 	_c_current = (float)(0);
 
-	_disabled = false;
 	_modifier_apply_type = modifier_apply_type;
 	_id = id;
 }
@@ -61,7 +58,6 @@ Stat::Stat(Stat::StatId id, StatModifierApplyType modifier_apply_type, float bas
 	_s_current = (float)(0);
 	_c_max = (float)(0);
 	_c_current = (float)(0);
-	_disabled = false;
 	_modifier_apply_type = modifier_apply_type;
 
 	_id = id;
@@ -70,7 +66,6 @@ Stat::Stat(Stat::StatId id, StatModifierApplyType modifier_apply_type, float bas
 	_bonus = bonus;
 	_percent = percent;
 
-	_disabled = false;
 }
 
 Stat::Stat(Stat::StatId id, StatModifierApplyType modifier_apply_type, float base) {
@@ -84,14 +79,11 @@ Stat::Stat(Stat::StatId id, StatModifierApplyType modifier_apply_type, float bas
 	_c_max = (float)(0);
 	_c_current = (float)(0);
 
-	_disabled = false;
 	_modifier_apply_type = modifier_apply_type;
 	_id = id;
 	_base = base;
 	_percent = 100;
 	_bonus = 0;
-
-	_disabled = false;
 }
 
 Stat::~Stat() {
@@ -144,18 +136,8 @@ void Stat::set_dirty(bool value) {
 	_dirty = value;
 }
 
-bool Stat::get_disabled() {
-	return _disabled;
-}
-
-void Stat::set_disabled(bool value) {
-	_disabled = value;
-
-	emit_signal("s_changed", this);
-}
-
-void Stat::add_modifier(int id, float _max_mod, float percent_mod, bool apply) {
-	Ref<StatModifier> statModifier = Ref<StatModifier>(memnew(StatModifier(id, _max_mod, percent_mod)));
+void Stat::add_modifier(int id, float base_mod, float bonus_mod, float percent_mod, bool apply) {
+	Ref<StatModifier> statModifier = Ref<StatModifier>(memnew(StatModifier(id, base_mod, bonus_mod, percent_mod)));
 
 	if (apply) {
 		apply_modifier(statModifier);
@@ -181,10 +163,12 @@ void Stat::remove_modifier(int id, bool apply) {
 
 void Stat::apply_modifier(Ref<StatModifier> modifier) {
 	if (_modifier_apply_type == MODIFIER_APPLY_TYPE_STANDARD) {
+		_base += modifier->get_base_mod();
 		_bonus += modifier->get_bonus_mod();
 		_percent += modifier->get_percent_mod();
 	} else {
 		if (modifier->get_percent_mod() >= (float)0) {
+			_base += modifier->get_base_mod();
 			_bonus += modifier->get_bonus_mod();
 			_percent += modifier->get_percent_mod();
 		} else {
@@ -211,16 +195,22 @@ void Stat::apply_modifier(Ref<StatModifier> modifier) {
 			}
 		}
 	}
+	
+	recalculate();
+	emit_signal("s_changed", this);
+	send();
 	//	emit_signal("s_changed", this);
 }
 
 void Stat::de_apply_modifier(Ref<StatModifier> modifier) {
 	if (_modifier_apply_type == MODIFIER_APPLY_TYPE_STANDARD) {
+		_base -= modifier->get_base_mod();
 		_bonus -= modifier->get_bonus_mod();
 		_percent -= modifier->get_percent_mod();
 	} else {
 		if (modifier->get_percent_mod() >= (float)0) {
-			//_bonus -= modifier->get_bonus_mod();
+			_base -= modifier->get_base_mod();
+			_bonus -= modifier->get_bonus_mod();
 			_percent -= modifier->get_percent_mod();
 		} else {
 			int num = -1;
@@ -242,10 +232,10 @@ void Stat::de_apply_modifier(Ref<StatModifier> modifier) {
 		}
 	}
 
-	if (_modifiers.size() == 0) {
-		recalculate();
-	}
-
+	recalculate();
+	emit_signal("s_changed", this);
+	send();
+	
 	//	emit_signal("s_changed", this);
 }
 
@@ -256,16 +246,17 @@ void Stat::re_apply_modifiers() {
 		for (int i = 0; i < _modifiers.size(); i += 1) {
 			Ref<StatModifier> mod = _modifiers.get(i);
 
+			_base += mod->get_base_mod();
 			_bonus += mod->get_bonus_mod();
 			_percent += mod->get_percent_mod();
 		}
 	} else {
 		re_apply_modifier_not_negative_stacking_percents();
 	}
-
-	if (_modifiers.size() == 0) {
-		recalculate();
-	}
+	
+	recalculate();
+	emit_signal("s_changed", this);
+	send();
 
 	//	emit_signal("s_changed", this);
 }
@@ -277,6 +268,7 @@ void Stat::re_apply_modifier_not_negative_stacking_percents() {
 		if (_modifiers.get(i)->get_percent_mod() > (float)0) {
 			Ref<StatModifier> mod = _modifiers.get(i);
 
+			_base += mod->get_base_mod();
 			_bonus += mod->get_bonus_mod();
 			_percent += mod->get_percent_mod();
 		}
@@ -298,10 +290,15 @@ void Stat::re_apply_modifier_not_negative_stacking_percents() {
 	if (num != -1) {
 		Ref<StatModifier> mod = _modifiers.get(num);
 
+		_base += mod->get_base_mod();
 		_bonus += mod->get_bonus_mod();
 		_percent += mod->get_percent_mod();
 	}
 
+	recalculate();
+	emit_signal("s_changed", this);
+	send();
+	
 	//	emit_signal("s_changed", this);
 }
 
@@ -386,10 +383,6 @@ void Stat::set_percent(float value) {
 }
 
 void Stat::reset_values() {
-	if (_disabled) {
-		return;
-	}
-
 	_percent = 100;
 	_bonus = 0;
 	_percent = 0;
@@ -401,15 +394,15 @@ void Stat::reset_values() {
 }
 
 void Stat::recalculate() {
-	if (_disabled) {
-		return;
-	}
-
-	_s_max = (_percent / (float)100) * (_base + _bonus);
+	float diff = _s_current / _s_max;
+	
+	_s_max = (_base + _bonus) * (_percent / 100.0);
 
 	if (_s_current > _s_max) {
 		_s_current = _s_max;
 	}
+	
+	_s_current = _s_max * diff;
 
 	_dirty = true;
 }
@@ -441,7 +434,6 @@ void Stat::set_values(float base, float bonus, float percent) {
 	_base = base;
 	_bonus = bonus;
 	_percent = percent;
-	_disabled = false;
 
 	recalculate();
 
@@ -472,7 +464,6 @@ void Stat::set(float current, float max, float base, float bonus, float percent)
 	_bonus = bonus;
 	_percent = percent;
 	_dirty = true;
-	_disabled = false;
 
 	emit_signal("s_changed", this);
 	send();
@@ -493,10 +484,6 @@ void Stat::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_dirty", "value"), &Stat::set_dirty);
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "is_dirty"), "set_dirty", "get_dirty");
 
-	ClassDB::bind_method(D_METHOD("get_disabled"), &Stat::get_disabled);
-	ClassDB::bind_method(D_METHOD("set_disabled", "value"), &Stat::set_disabled);
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "dirty"), "set_disabled", "get_disabled");
-
 	ClassDB::bind_method(D_METHOD("gets_current"), &Stat::gets_current);
 	ClassDB::bind_method(D_METHOD("sets_current", "value"), &Stat::sets_current);
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "scurrent"), "sets_current", "gets_current");
@@ -543,7 +530,7 @@ void Stat::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("re_apply_modifier_not_negative_stacking_percents"), &Stat::re_apply_modifier_not_negative_stacking_percents);
 
 
-	ClassDB::bind_method(D_METHOD("add_modifier", "id", "maxMod", "percentMod", "apply"), &Stat::add_modifier);
+	ClassDB::bind_method(D_METHOD("add_modifier", "id", "base_mod", "bonus_mod", "percent_mod", "apply"), &Stat::add_modifier);
 	ClassDB::bind_method(D_METHOD("remove_modifier", "id", "apply"), &Stat::remove_modifier);
 	ClassDB::bind_method(D_METHOD("re_apply_modifiers"), &Stat::re_apply_modifiers);
 
diff --git a/entities/stats/stat.h b/entities/stats/stat.h
index b06208d..10d6517 100644
--- a/entities/stats/stat.h
+++ b/entities/stats/stat.h
@@ -6,46 +6,7 @@
 #include "core/vector.h"
 #include "scene/resources/curve.h"
 
-class StatModifier : public Reference {
-	GDCLASS(StatModifier, Reference);
-
-public:
-	StatModifier() {
-	}
-
-	StatModifier(int i, float maxM, float percentM) {
-		_id = i;
-		_max_mod = maxM;
-		_percent_mod = percentM;
-	}
-
-	int get_id() { return _id; }
-	void set_id(int value) { _id = value; }
-	float get_bonus_mod() { return _max_mod; }
-	void set_bonus_mod(float value) { _max_mod = value; }
-	float get_percent_mod() { return _percent_mod; }
-	void set_percent_mod(float value) { _percent_mod = value; }
-
-protected:
-	static void _bind_methods() {
-		ClassDB::bind_method(D_METHOD("get_id"), &StatModifier::get_id);
-		ClassDB::bind_method(D_METHOD("set_id", "value"), &StatModifier::set_id);
-		ADD_PROPERTY(PropertyInfo(Variant::REAL, "id"), "set_id", "get_id");
-
-		ClassDB::bind_method(D_METHOD("get_bonus_mod"), &StatModifier::get_bonus_mod);
-		ClassDB::bind_method(D_METHOD("set_bonus_mod", "value"), &StatModifier::set_bonus_mod);
-		ADD_PROPERTY(PropertyInfo(Variant::REAL, "bonus_mod"), "set_bonus_mod", "get_bonus_mod");
-
-		ClassDB::bind_method(D_METHOD("get_percent_mod"), &StatModifier::get_percent_mod);
-		ClassDB::bind_method(D_METHOD("set_percent_mod", "value"), &StatModifier::set_percent_mod);
-		ADD_PROPERTY(PropertyInfo(Variant::REAL, "percent_mod"), "set_percent_mod", "get_percent_mod");
-	}
-
-private:
-	int _id;
-	float _max_mod;
-	float _percent_mod;
-};
+#include "stat_modifier.h"
 
 class Stat : public Reference {
 	GDCLASS(Stat, Reference);
@@ -128,8 +89,6 @@ public:
 
 	bool get_dirty();
 	void set_dirty(bool value);
-	bool get_disabled();
-	void set_disabled(bool value);
 
 	float get_base();
 	void set_base(float value);
@@ -152,7 +111,7 @@ public:
 	void recalculate();
 	bool iss_current_zero();
 	bool isc_current_zero();
-	void set(float current, float max, float modCurrent, float modMax, float modPercent);
+	void set(float current, float max, float base, float bonus, float percent);
 	void set_from_stat(Ref<Stat> other);
 
 	void set_to_max();
@@ -163,7 +122,7 @@ public:
 	void re_apply_modifier_not_negative_stacking_percents();
 
 	Vector<Ref<StatModifier> > *get_modifiers();
-	void add_modifier(int id, float maxMod, float percentMod, bool apply = true);
+	void add_modifier(int id, float base_mod, float bonus_mod, float percent_mod, bool apply = true);
 	void remove_modifier(int id, bool apply = true);
 	void re_apply_modifiers();
 	int get_modifier_count();
@@ -185,7 +144,6 @@ private:
 	Vector<Ref<StatModifier> > _modifiers;
 
 	bool _dirty;
-	bool _disabled;
 
 	float _base;
 	float _bonus;
diff --git a/entities/stats/stat_modifier.cpp b/entities/stats/stat_modifier.cpp
new file mode 100644
index 0000000..ce52550
--- /dev/null
+++ b/entities/stats/stat_modifier.cpp
@@ -0,0 +1 @@
+#include "stat_modifier.h"
diff --git a/entities/stats/stat_modifier.h b/entities/stats/stat_modifier.h
new file mode 100644
index 0000000..354a58d
--- /dev/null
+++ b/entities/stats/stat_modifier.h
@@ -0,0 +1,62 @@
+#ifndef STAT_MODIFIER_H
+#define STAT_MODIFIER_H
+
+#include "core/reference.h"
+
+class StatModifier : public Reference {
+	GDCLASS(StatModifier, Reference);
+
+public:
+	StatModifier() {
+		_id = 0;
+		_base_mod = 0;
+		_bonus_mod = 0;
+		_percent_mod = 0;
+	}
+
+	StatModifier(int i, float base_mod, float bonus_mod, float percent_mod) {
+		_id = i;
+		_base_mod = base_mod;
+		_bonus_mod = bonus_mod;
+		_percent_mod = percent_mod;
+	}
+
+	int get_id() { return _id; }
+	void set_id(int value) { _id = value; }
+	
+	float get_base_mod() { return _base_mod; }
+	void set_base_mod(float value) { _base_mod = value; }
+	
+	float get_bonus_mod() { return _bonus_mod; }
+	void set_bonus_mod(float value) { _bonus_mod = value; }
+	
+	float get_percent_mod() { return _percent_mod; }
+	void set_percent_mod(float value) { _percent_mod = value; }
+
+protected:
+	static void _bind_methods() {
+		ClassDB::bind_method(D_METHOD("get_id"), &StatModifier::get_id);
+		ClassDB::bind_method(D_METHOD("set_id", "value"), &StatModifier::set_id);
+		ADD_PROPERTY(PropertyInfo(Variant::INT, "id"), "set_id", "get_id");
+
+		ClassDB::bind_method(D_METHOD("get_base_mod"), &StatModifier::get_base_mod);
+		ClassDB::bind_method(D_METHOD("set_base_mod", "value"), &StatModifier::set_base_mod);
+		ADD_PROPERTY(PropertyInfo(Variant::REAL, "base_mod"), "set_base_mod", "get_base_mod");
+		
+		ClassDB::bind_method(D_METHOD("get_bonus_mod"), &StatModifier::get_bonus_mod);
+		ClassDB::bind_method(D_METHOD("set_bonus_mod", "value"), &StatModifier::set_bonus_mod);
+		ADD_PROPERTY(PropertyInfo(Variant::REAL, "bonus_mod"), "set_bonus_mod", "get_bonus_mod");
+
+		ClassDB::bind_method(D_METHOD("get_percent_mod"), &StatModifier::get_percent_mod);
+		ClassDB::bind_method(D_METHOD("set_percent_mod", "value"), &StatModifier::set_percent_mod);
+		ADD_PROPERTY(PropertyInfo(Variant::REAL, "percent_mod"), "set_percent_mod", "get_percent_mod");
+	}
+
+private:
+	int _id;
+	float _base_mod;
+	float _bonus_mod;
+	float _percent_mod;
+};
+
+#endif
diff --git a/register_types.cpp b/register_types.cpp
index 16fd10b..36fe893 100644
--- a/register_types.cpp
+++ b/register_types.cpp
@@ -4,6 +4,7 @@
 #include "item_enums.h"
 
 #include "data/aura.h"
+#include "data/aura_stat_attribute.h"
 #include "data/data_manager.h"
 #include "data/character_class.h"
 #include "data/talent.h"
@@ -20,6 +21,7 @@
 
 #include "data/spell.h"
 #include "entities/stats/stat.h"
+#include "entities/stats/stat_modifier.h"
 #include "entities/stats/stat_data.h"
 #include "entities/player_talent.h"
 #include "inventory/bag_slot.h"
@@ -77,6 +79,8 @@ void register_entity_spell_system_types() {
 	ClassDB::register_class<CharacterClass>();
 	ClassDB::register_class<Spell>();
 	ClassDB::register_class<Aura>();
+	ClassDB::register_class<AuraStatAttribute>();
+	
 	ClassDB::register_class<XPData>();
 	ClassDB::register_class<ItemStatModifier>();
 	ClassDB::register_class<ItemTemplateStatModifier>();