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);
}
}
}
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 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 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);
}
protected override void ResetRuntimeData()
{
if (m_program != null)
{
RecyclableObject.Recycle(m_program);
m_program = null;
}
}
void RecycleVariable()
{
for (int i = 0; i < m_variables.Count; ++i)
{
RecyclableObject.Recycle(m_variables[i]);
}
m_variables.Clear();
}
public void DestroyRegion(EntityGatheringRegion region)
{
if (m_regions.Remove(region.ID))
{
region.Deactivate();
RecyclableObject.Recycle(region);
}
}
void ClearTargets()
{
for (int i = 0; i < m_targets.Count; ++i)
{
RecyclableObject.Recycle(m_targets[i]);
}
m_targets.Clear();
}
void ClearMovementProvider()
{
if (m_movement_provider != null)
{
RecyclableObject.Recycle(m_movement_provider);
m_movement_provider = 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 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);
}
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();
}
public void Reset()
{
m_constant = FixPoint.Zero;
if (m_program != null)
{
RecyclableObject.Recycle(m_program);
m_program = null;
}
}
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 void Reset()
{
if (m_text_buffer != null)
{
RecyclableObject.Recycle(m_text_buffer);
}
m_text_buffer = null;
m_error = false;
m_current_token = null;
}
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());
}
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();
}
protected override void OnDestruct()
{
RecyclableObject.Recycle(m_damage_amount);
m_damage_amount = null;
if (m_period_task != null)
{
m_period_task.Cancel();
LogicTask.Recycle(m_period_task);
m_period_task = null;
}
}
public void Reset()
{
m_logic_world = null;
m_id = 0;
m_data = null;
for (int i = 0; i < m_entries.Count; ++i)
{
RecyclableObject.Recycle(m_entries[i]);
}
m_entries.Clear();
m_remove_self_when_idle = false;
m_is_active = false;
}
protected override void OnDestruct()
{
if (m_param != null)
{
RecyclableObject.Recycle(m_param);
m_param = null;
}
if (m_task != null)
{
m_task.Cancel();
LogicTask.Recycle(m_task);
m_task = null;
}
}
public void ClearAllPrediction()
{
m_interpolation_tr.localPosition = Vector3.zero;
m_copy_state = NoCopy;
m_accumulated_offset = Vector3.zero;
m_offset_dir = Vector3.zero;
m_interpolation_time = -1f;
for (int i = 0; i < m_movement_predicts.Count; ++i)
{
MovementPredict predict = m_movement_predicts[i];
RecyclableObject.Recycle(predict);
}
m_movement_predicts.Clear();
}
public override void Destruct()
{
m_generator_id_generator = null;
var enumerator = m_generators.GetEnumerator();
while (enumerator.MoveNext())
{
EffectGenerator generator = enumerator.Current.Value;
RecyclableObject.Recycle(generator);
}
m_generators.Clear();
base.Destruct();
}
void ApplyGenerator(Entity entity)
{
LogicWorld logic_world = GetLogicWorld();
EffectGenerator generator = logic_world.GetEffectManager().GetGenerator(m_param.m_generator_id);
if (generator == null)
{
return;
}
EffectApplicationData app_data = RecyclableObject.Create <EffectApplicationData>();
app_data.m_original_entity_id = m_param.m_source_entity_id;
app_data.m_source_entity_id = GetOwnerEntityID();
generator.Activate(app_data, entity);
RecyclableObject.Recycle(app_data);
}
public virtual bool Compile(string formula_string)
{
m_error_occurred = false;
m_tokenizer = RecyclableObject.Create <Tokenizer>();
m_tokenizer.Construct(formula_string);
m_token = null;
m_token_type = TokenType.ERROR;
GetToken();
ParseExpression();
RecyclableObject.Recycle(m_tokenizer);
m_tokenizer = null;
m_token = null;
m_token_type = TokenType.ERROR;
m_raw_variable.Clear();
return(!m_error_occurred);
}
protected override void OnDestruct()
{
if (m_listener_context != null)
{
ParentObject.RemoveListener(SignalType.ChangeLevel, m_listener_context.ID);
SignalListenerContext.Recycle(m_listener_context);
m_listener_context = null;
}
var enumerator = m_attributes.GetEnumerator();
while (enumerator.MoveNext())
{
RecyclableObject.Recycle(enumerator.Current.Value);
}
m_attributes.Clear();
}
public void Destruct()
{
m_id_generator.Destruct();
m_id_generator = null;
var enumerator = m_regions.GetEnumerator();
while (enumerator.MoveNext())
{
EntityGatheringRegion region = enumerator.Current.Value;
region.Deactivate();
RecyclableObject.Recycle(region);
}
m_regions.Clear();
m_active_region_bundles.Clear();
m_logic_world = null;
}
void ApplyOnce()
{
if (m_remain_count > 0)
{
--m_remain_count;
}
if (m_remain_count == 0)
{
CancelTask();
}
Entity owner = GetOwnerEntity();
EffectDefinitionComponent definition_component = ((Effect)ParentObject).GetDefinitionComponent();
EffectApplicationData app_data = RecyclableObject.Create <EffectApplicationData>();
app_data.m_original_entity_id = definition_component.OriginalEntityID;
app_data.m_source_entity_id = owner.ID;
m_generator.Activate(app_data, owner);
RecyclableObject.Recycle(app_data);
}
void RecycleRenderEffectInfo(RenderEffectInfo info, RenderEffectData config)
{
if (info.m_task != null)
{
RenderTask.Recycle(info.m_task);
info.m_task = null;
}
if (info.m_go != null)
{
if (config == null)
{
config = GetRenderWorld().GetRenderEffectData(info.m_render_effect_cfgid);
}
info.m_go.transform.parent = null;
UnityResourceManager.Instance.RecycleGameObject(config.m_prefab, info.m_go);
info.m_go = null;
}
RecyclableObject.Recycle(info);
}
public bool Compile(string formula_string)
{
ExpressionProgram program = RecyclableObject.Create <ExpressionProgram>();
if (!program.Compile(formula_string))
{
return(false);
}
if (program.IsConstant())
{
m_constant = program.Evaluate(null);
m_program = null;
RecyclableObject.Recycle(program);
}
else
{
m_program = program;
}
return(true);
}
