public void Construct(AttributeManagerComponent owner_component, AttributeDefinition definition, string base_value)
{
m_owner_component = owner_component;
m_definition = definition;
m_base_value_formula = RecyclableObject.Create <Formula>();
m_base_value_formula.Compile(base_value);
int count = 0;
List <ExpressionVariable> variables = m_base_value_formula.GetAllVariables();
if (variables != null)
{
count = variables.Count;
}
for (int i = 0; i < count; ++i)
{
ExpressionVariable variable = variables[i];
if (variable.MaxIndex == 1 && variable[0] == ExpressionVariable.VID_LevelTable)
{
m_is_level_based = true;
}
}
ComputeValue();
m_definition.Reflect(m_owner_component.ParentObject, this, true);
}
public override void ResetNode()
{
if (m_listener_context != null)
{
Entity owner = m_context.GetData <Entity>(BTContextKey.OwnerEntity);
for (int i = 0; i < m_signal_datas.Count; ++i)
{
owner.RemoveListener(m_signal_datas[i].m_signal_id, m_listener_context.ID);
}
SignalListenerContext.Recycle(m_listener_context);
m_listener_context = null;
m_context.GetLogicWorld().UnregisterBehaviorTree(this);
m_register_id = 0;
}
ClearRunningTrace();
base.ResetNode();
if (m_context != null)
{
BTContext context = m_context;
SetContext(null);
RecyclableObject.Recycle(context);
}
m_current_running_entry_index = -1;
if (m_task != null)
{
m_task.Cancel();
LogicTask.Recycle(m_task);
m_task = null;
}
}
public void RecycleAllRenderEffects()
{
var enumerator = m_nodes.GetEnumerator();
while (enumerator.MoveNext())
{
RenderEffectNode node = enumerator.Current.Value;
for (int i = 0; i < node.m_render_effects.Count; ++i)
{
RenderEffectInfo info = node.m_render_effects[i];
RenderEffectData config = GetRenderWorld().GetRenderEffectData(info.m_render_effect_cfgid);
if (info.m_task != null)
{
RenderTask.Recycle(info.m_task);
info.m_task = null;
}
if (info.m_go != null)
{
info.m_go.transform.parent = null;
UnityResourceManager.Instance.RecycleGameObject(config.m_prefab, info.m_go);
info.m_go = null;
}
node.m_render_effects.RemoveAt(i);
RecyclableObject.Recycle(info);
}
}
}
void CreateAttribute(int id, string base_value)
{
AttributeDefinition definition = AttributeSystem.Instance.GetDefinitionByID(id);
if (definition == null)
{
return;
}
List <int> referenced_ids = definition.GetReferencedAttributes();
for (int i = 0; i < referenced_ids.Count; ++i)
{
if (!m_attributes.ContainsKey(referenced_ids[i]))
{
string referenced_attribute_base_value;
if (!m_base_value.TryGetValue(referenced_ids[i], out referenced_attribute_base_value))
{
referenced_attribute_base_value = null;
}
CreateAttribute(referenced_ids[i], referenced_attribute_base_value);
}
}
Attribute attribute = RecyclableObject.Create <Attribute>();
attribute.Construct(this, definition, base_value);
m_attributes[id] = attribute;
}
public void OnEntityEnter(int entity_id)
{
Entity owner = GetOwnerEntity();
if (ObjectUtil.IsDead(owner))
{
return;
}
if (m_enter_generator == null)
{
return;
}
Entity entity = GetLogicWorld().GetEntityManager().GetObject(entity_id);
if (entity == null)
{
return;
}
if (ObjectUtil.IsDead(entity))
{
return;
}
EffectApplicationData app_data = RecyclableObject.Create <EffectApplicationData>();
app_data.m_original_entity_id = ParentObject.ID;
app_data.m_source_entity_id = ParentObject.ID;
m_enter_generator.Activate(app_data, entity);
RecyclableObject.Recycle(app_data);
}
public void DestroyGenerator(int generator_id, int owner_entity_id)
{
EffectGenerator generator;
if (!m_generators.TryGetValue(generator_id, out generator))
{
return;
}
if (generator.RemoveBySelf && !generator.RemoveSelfWhenIdle)
{
generator.RemoveSelfWhenIdle = true;
}
else
{
generator.ForceDeactivate();
m_generators.Remove(generator_id);
Entity owner = m_logic_world.GetEntityManager().GetObject(owner_entity_id);
EffectGeneratorRegistry registry = EntityUtil.GetEffectGeneratorRegistry(owner);
if (registry != null)
{
registry.RemoveGenerator(generator_id);
}
RecyclableObject.Recycle(generator);
}
}
public void BuildSkillTargets()
{
ClearTargets();
if (m_definition_component.m_target_gathering_param.m_type == TargetGatheringType.SpecifiedTarget)
{
if (m_definition_component.ExternalDataType == SkillDefinitionComponent.NeedExternalTarget)
{
int specified_target_id = m_definition_component.ExternalID;
if (specified_target_id > 0)
{
Target target = RecyclableObject.Create <Target>();
target.Construct();
target.SetEntityTarget(specified_target_id);
m_skill_targets.Add(target);
}
}
else if (m_definition_component.ExternalDataType == SkillDefinitionComponent.NeedExternalOffset)
{
PositionComponent position_component = GetOwnerEntity().GetComponent(PositionComponent.ID) as PositionComponent;
Target target = RecyclableObject.Create <Target>();
target.Construct();
target.SetPositionTarget(position_component.CurrentPosition + m_definition_component.ExternalVector);
m_skill_targets.Add(target);
}
}
else
{
TargetGatheringManager target_gathering_manager = GetLogicWorld().GetTargetGatheringManager();
target_gathering_manager.BuildTargetList(GetOwnerEntity(), m_definition_component.m_target_gathering_param, m_skill_targets);
}
}
protected override void OnActionUpdate(FixPoint delta_time)
{
SkillComponent skill_component = m_context.GetData <SkillComponent>(BTContextKey.OwnerSkillComponent);
Skill skill = skill_component.GetOwnerSkill();
Entity attacker = skill.GetOwnerEntity();
List <Target> targets = skill.GetTargets();
LogicWorld logic_world = skill.GetLogicWorld();
for (int i = 0; i < targets.Count; ++i)
{
Entity current_target = targets[i].GetEntity(logic_world);
if (current_target == null)
{
continue;
}
skill_component.CurrentTarget = current_target;
DamagableComponent damageable_component = current_target.GetComponent(DamagableComponent.ID) as DamagableComponent;
if (damageable_component == null)
{
continue;
}
Damage damage = RecyclableObject.Create <Damage>();
damage.m_attacker_id = attacker.ID;
damage.m_defender_id = current_target.ID;
damage.m_damage_type = m_damage_type_id;
damage.m_damage_amount = m_damage_amount.Evaluate(this);
damage.m_damage_amount = DamageSystem.Instance.CalculateDamageAmount(m_damage_type_id, damage.m_damage_amount, attacker, current_target);
damage.m_render_effect_cfgid = m_damage_render_effect_cfgid;
damage.m_sound_cfgid = m_damage_sound_cfgid;
damageable_component.TakeDamage(damage);
}
skill_component.CurrentTarget = null;
}
public override void InitializeVariable(Dictionary <string, string> variables)
{
string value;
if (variables.TryGetValue("count", out value))
{
m_count = int.Parse(value);
m_modefier_configs = new AttributeModifierConfig[m_count];
Prepare(m_count);
}
for (int i = 0; i < m_count; ++i)
{
AttributeModifierConfig modifier = RecyclableObject.Create <AttributeModifierConfig>();
m_modefier_configs[i] = modifier;
if (variables.TryGetValue(m_attribute_name_key[i], out value))
{
modifier.m_attribute_id = (int)CRC.Calculate(value);
}
if (variables.TryGetValue(m_attribute_category_key[i], out value))
{
modifier.m_attribute_category = (int)CRC.Calculate(value);
}
if (variables.TryGetValue(m_value_key[i], out value))
{
modifier.m_value.Compile(value);
}
}
}
public void DestroyRegion(EntityGatheringRegion region)
{
if (m_regions.Remove(region.ID))
{
region.Deactivate();
RecyclableObject.Recycle(region);
}
}
void ClearMovementProvider()
{
if (m_movement_provider != null)
{
RecyclableObject.Recycle(m_movement_provider);
m_movement_provider = null;
}
}
void RecycleVariable()
{
for (int i = 0; i < m_variables.Count; ++i)
{
RecyclableObject.Recycle(m_variables[i]);
}
m_variables.Clear();
}
protected override void ResetRuntimeData()
{
if (m_program != null)
{
RecyclableObject.Recycle(m_program);
m_program = null;
}
}
public EntityGatheringRegion CreateRegion()
{
EntityGatheringRegion region = RecyclableObject.Create <EntityGatheringRegion>();
region.PreConstruct(this);
m_regions[region.ID] = region;
return(region);
}
void ClearTargets()
{
for (int i = 0; i < m_targets.Count; ++i)
{
RecyclableObject.Recycle(m_targets[i]);
}
m_targets.Clear();
}
protected override void OnDestruct()
{
for (int i = 0; i < m_movement_predicts.Count; ++i)
{
MovementPredict predict = m_movement_predicts[i];
RecyclableObject.Recycle(predict);
}
m_movement_predicts.Clear();
}
protected override void OnDestruct()
{
for (int i = 0; i < m_count; ++i)
{
RecyclableObject.Recycle(m_modefier_configs[i]);
}
m_modefier_configs = null;
m_modifier_ids = null;
}
public static SignalListenerContext CreateForBehaviorTree(int listener_id, int tree_id)
{
SignalListenerContext context = RecyclableObject.Create <SignalListenerContext>();
context.m_context_type = SignalListenerContextType.BehaviorTree;
context.m_listener_id = listener_id;
context.m_object_id = tree_id;
return(context);
}
public void Reset()
{
m_constant = FixPoint.Zero;
if (m_program != null)
{
RecyclableObject.Recycle(m_program);
m_program = null;
}
}
void ApplyGenerator(EffectGenerator generator)
{
EffectApplicationData app_data = RecyclableObject.Create <EffectApplicationData>();
app_data.m_original_entity_id = ParentObject.ID;
app_data.m_source_entity_id = ParentObject.ID;
generator.Activate(app_data, GetOwnerEntity());
RecyclableObject.Recycle(app_data);
}
public void CopyFrom(Formula rhs)
{
m_constant = rhs.m_constant;
if (rhs.m_program != null)
{
m_program = RecyclableObject.Create <ExpressionProgram>();
m_program.CopyFrom(rhs.m_program);
}
}
public void OnEntityBeKilled(Entity the_killer, Entity the_dead)
{
KillingInfo info = RecyclableObject.Create <KillingInfo>();
info.m_the_killer = the_killer;
info.m_the_dead = the_dead;
SendSignal(SignalType.EntityBeKilled, info);
RecyclableObject.Recycle(info);
}
public void Impact()
{
#if COMBAT_CLIENT
if (m_render_effect_cfgid > 0)
{
if (m_remain_attack_cnt != m_combo_attack_cnt)
{
PlayRenderEffectMessage stop_msg = RenderMessage.Create <PlayRenderEffectMessage>();
stop_msg.ConstructAsStop(GetOwnerEntityID(), m_render_effect_cfgid);
GetLogicWorld().AddRenderMessage(stop_msg);
}
PlayRenderEffectMessage start_msg = RenderMessage.Create <PlayRenderEffectMessage>();
start_msg.ConstructAsPlay(GetOwnerEntityID(), m_render_effect_cfgid, FixPoint.MinusOne);
GetLogicWorld().AddRenderMessage(start_msg);
}
#endif
--m_remain_attack_cnt;
if (m_remain_attack_cnt <= 0)
{
if (m_combo_task != null)
{
m_combo_task.Cancel();
}
}
Skill skill = GetOwnerSkill();
if (!skill.GetDefinitionComponent().NeedGatherTargets)
{
skill.BuildSkillTargets();
}
Entity attacker = GetOwnerEntity();
List <Target> targets = skill.GetTargets();
LogicWorld logic_world = GetLogicWorld();
for (int i = 0; i < targets.Count; ++i)
{
m_current_target = targets[i].GetEntity(logic_world);
if (m_current_target == null)
{
continue;
}
DamagableComponent damageable_component = m_current_target.GetComponent(DamagableComponent.ID) as DamagableComponent;
if (damageable_component == null)
{
continue;
}
Damage damage = RecyclableObject.Create <Damage>();
damage.m_attacker_id = attacker.ID;
damage.m_defender_id = m_current_target.ID;
damage.m_damage_type = m_damage_type_id;
damage.m_damage_amount = m_damage_amount.Evaluate(this);
damage.m_damage_amount = DamageSystem.Instance.CalculateDamageAmount(m_damage_type_id, damage.m_damage_amount, attacker, m_current_target);
damage.m_render_effect_cfgid = m_damage_render_effect_cfgid;
damage.m_sound_cfgid = m_damage_sound_cfgid;
damageable_component.TakeDamage(damage);
}
m_current_target = null;
}
public void Reset()
{
if (m_text_buffer != null)
{
RecyclableObject.Recycle(m_text_buffer);
}
m_text_buffer = null;
m_error = false;
m_current_token = null;
}
public static SignalListenerContext CreateForEffectComponent(int listener_id, int effect_id, int component_type_id)
{
SignalListenerContext context = RecyclableObject.Create <SignalListenerContext>();
context.m_context_type = SignalListenerContextType.EffectComponent;
context.m_listener_id = listener_id;
context.m_object_id = effect_id;
context.m_component_type_id = component_type_id;
return(context);
}
int AddVariable(List <string> raw_variable)
{
ExpressionVariable variable = RecyclableObject.Create <ExpressionVariable>();
variable.Construct(raw_variable);
int index = m_variables.Count;
m_variables.Add(variable);
return(index);
}
public void KillOwner(int killer_id)
{
//ZZWTODO Resurrect
if (m_die_task != null)
{
m_die_task.Cancel();
}
LogicWorld logic_world = GetLogicWorld();
Entity killer = logic_world.GetEntityManager().GetObject(killer_id);
if (!DieSilently && killer_id != ParentObject.ID && m_killer_generator != null && killer != null)
{
EffectApplicationData app_data = RecyclableObject.Create <EffectApplicationData>();
app_data.m_original_entity_id = ParentObject.ID;
app_data.m_source_entity_id = ParentObject.ID;
m_killer_generator.Activate(app_data, killer);
RecyclableObject.Recycle(app_data);
}
var schedeler = logic_world.GetTaskScheduler();
if (DieSilently)
{
logic_world.AddSimpleRenderMessage(RenderMessageType.Hide, ParentObject.ID);
}
else
{
HideEntityTask hide_task = LogicTask.Create <HideEntityTask>();
hide_task.Construct(ParentObject.ID);
schedeler.Schedule(hide_task, GetCurrentTime(), m_hide_delay);
}
ParentObject.DeletePending = true;
ParentObject.SendSignal(SignalType.Die);
logic_world.AddSimpleRenderMessage(RenderMessageType.Die, ParentObject.ID);
StateComponent state_component = ParentObject.GetComponent(StateComponent.ID) as StateComponent;
if (state_component != null)
{
state_component.AddState(StateSystem.DEAD_STATE, 0);
}
if (!m_can_resurrect)
{
DeleteEntityTask delete_task = LogicTask.Create <DeleteEntityTask>();
delete_task.Construct(ParentObject.ID);
schedeler.Schedule(delete_task, GetCurrentTime(), m_delete_delay);
}
logic_world.OnKillEntity(killer, GetOwnerEntity());
}
protected override void OnActionUpdate(FixPoint delta_time)
{
if (m_program == null)
{
m_program = RecyclableObject.Create <ExpressionProgram>();
m_program.Compile(m_context_value_expression);
}
FixPoint context_value = m_program.Evaluate(this);
m_context.SetData(m_context_key, context_value);
}
public void RemoveModifier(int modifier_id)
{
AttributeModifier modifier;
if (!m_modifiers.TryGetValue(modifier_id, out modifier))
{
return;
}
m_modifiers.Remove(modifier_id);
RecyclableObject.Recycle(modifier);
MarkDirty();
}
void ClearTargets()
{
if (m_targets == null)
{
return;
}
for (int i = 0; i < m_targets.Count; ++i)
{
RecyclableObject.Recycle(m_targets[i]);
}
m_targets.Clear();
}
