public List <CombatEventTree> GetParentsAndSiblings(CombatEventTree cut)
{
List <CombatEventTree> list = new List <CombatEventTree>();
if (m_parent == null)
{
return(list);
}
list = TreeToList(m_parent, this);
CombatEventTree from = m_parent;
var iter = m_parent.GetParentsNonAlloc();
while (iter.MoveNext())
{
CombatEventTree ancestor = iter.Current;
if (ancestor == cut)
{
break;
}
List <CombatEventTree> ancestors = TreeToList(ancestor, from);
list.AddRange(ancestors);
from = ancestor;
}
iter.Dispose();
return(list);
}
public System.ArraySegment <CombatEventTree> GetParents()
{
int count = 0;
int bufferLength = parentBuffer.Length;
var iter = m_parent;
while (iter != null)
{
if (count == bufferLength)
{
int reallocLength = bufferLength > 0 ? bufferLength * 2 : 1;
var realloc = new CombatEventTree[reallocLength];
if (bufferLength > 0)
{
System.Array.Copy(parentBuffer, realloc, bufferLength);
}
parentBuffer = realloc;
bufferLength = reallocLength;
}
parentBuffer[count++] = iter;
iter = iter.Parent;
}
return(new System.ArraySegment <CombatEventTree>(parentBuffer, 0, count));
}
public bool IsParentsAndSiblingsDone(CombatEventTree cut)
{
if (m_parent == null)
{
return(true);
}
if (!IsTreeDone(m_parent, this))
{
return(false);
}
CombatEventTree from = m_parent;
var iter = m_parent.GetParentsNonAlloc();
while (iter.MoveNext())
{
CombatEventTree ancestor = iter.Current;
if (ancestor == cut)
{
break;
}
if (!IsTreeDone(ancestor, from))
{
return(false);
}
from = ancestor;
}
iter.Dispose();
return(true);
}
public System.ArraySegment <CombatEventTree> GetChildren()
{
int bufferLength = childrenBuffer.Length;
int len = 0;
var iter = m_children.GetEnumerator();
while (iter.MoveNext())
{
var pair = iter.Current;
List <CombatEventTree> tree_list = pair.Value;
for (int i = 0, cnt = tree_list.Count; i < cnt; ++i)
{
CombatEventTree tree = tree_list[i];
// check buffer size
if (len == bufferLength)
{
var reallocLength = bufferLength > 0 ? bufferLength * 2 : 1;
var realloc = new CombatEventTree[reallocLength];
if (bufferLength > 0)
{
System.Array.Copy(childrenBuffer, realloc, bufferLength);
}
childrenBuffer = realloc;
bufferLength = reallocLength;
}
childrenBuffer[len++] = tree;
}
}
iter.Dispose();
return(new System.ArraySegment <CombatEventTree>(childrenBuffer, 0, len));
}
public static CombatEventTree Parse(CombatEvent evt)
{
CombatEventTree root = new CombatEventTree();
root.Event = evt;
root.NodeState = CombatEventTreeState.INITED;
root.TreeState = CombatEventTreeState.INITED;
if (evt.Children == null)
{
return(root);
}
// children are CombatEffectEvent
for (int i = 0, cnt = evt.Children.Count; i < cnt; ++i)
{
CombatEffectEvent effect = evt.Children[i] as CombatEffectEvent;
CombatEventTree sub_tree = Parse(effect);
if (effect.Parent < 0)
{
root.AddChild(sub_tree);
}
else
{
CombatEvent parent_effect = evt.Children[effect.Parent];
CombatEventTree parent = root.FindInChildren(parent_effect);
parent.AddChild(sub_tree);
}
}
return(root);
}
protected void UpdateCollide()
{
List <CombatEventTree> collide_queue = CalculateCollideList();
if (collide_queue == null)
{
return;
}
Vector3 move_direction = CollidePoint - BackPoint;
int len = collide_queue.Count;
for (int i = 0; i < len; i++)
{
CombatEventTree node = collide_queue[i];
if (node.NodeState != CombatEventTreeState.INITED)
{
continue;
}
if (node.Event.Type != eCombatEventType.EFFECT)
{
continue;
}
CombatEffectEvent effect = node.Event as CombatEffectEvent;
Combatant target = Hotfix_LT.UI.LTCombatEventReceiver.Instance.GetCombatant(effect.Target);
Vector3 direction_vector = target.transform.position - Combatant.transform.position;
if (Vector3.Dot(direction_vector, move_direction) < 0.0f)
{
//CombatEventReceiver.Instance.DoEventNode(node);
}
}
}
public CombatEventTree FindInSiblings(CombatEvent evt)
{
if (m_parent == null)
{
return(null);
}
// speed up
CombatEventTree found = null;
if (s_nodeCache.TryGetValue(evt.GetHashCode(), out found))
{
if (found.IsAncestor(m_parent) && found != this)
{
return(found);
}
}
EB.Debug.LogWarning("CombatEventTree.FindInSiblings: cache miss");
var iter = m_parent.GetChildrenNonAlloc();
while (iter.MoveNext())
{
CombatEventTree sibling = iter.Current;
if (sibling == this)
{
continue;
}
if (sibling.Event.Equals(evt))
{
iter.Dispose();
return(sibling);
}
}
iter.Dispose();
iter = m_parent.GetChildrenNonAlloc();
while (iter.MoveNext())
{
CombatEventTree sibling = iter.Current;
if (sibling == this)
{
continue;
}
found = sibling.FindInChildren(evt);
if (found != null)
{
iter.Dispose();
return(found);
}
}
iter.Dispose();
return(null);
}
public List <CombatEventTree> ChildrenToList()
{
List <CombatEventTree> list = new List <CombatEventTree>();
var iter = GetChildrenNonAlloc();
while (iter.MoveNext())
{
CombatEventTree child = iter.Current;
list.AddRange(TreeToList(child, null));
}
iter.Dispose();
return(list);
}
public bool Equals(CombatEventTree cmp_tree)
{
if (cmp_tree == null)
{
return(false);
}
if (cmp_tree == this)
{
return(true);
}
return(m_event.GetUniqueCode() == cmp_tree.Event.GetUniqueCode());
}
public bool IsAncestor(CombatEventTree ancestor_tree)
{
CombatEventTree iter = Parent;
while (iter != null)
{
if (iter == ancestor_tree)
{
return(true);
}
iter = iter.Parent;
}
return(false);
}
public bool IsChild(CombatEventTree sub_tree)
{
if (sub_tree.Parent != this)
{
return(false);
}
eCombatEventTiming timing = sub_tree.Event.Timing;
List <CombatEventTree> children = GetChildren(timing);
if (children == null)
{
return(false);
}
return(children.Contains(sub_tree));
}
public IEnumerator <CombatEventTree> ChildrenToListNonAlloc()
{
var iter = GetChildrenNonAlloc();
while (iter.MoveNext())
{
CombatEventTree child = iter.Current;
var children = TreeToListNonAlloc(child, null);
while (children.MoveNext())
{
yield return(children.Current);
}
children.Dispose();
}
iter.Dispose();
}
private static void ReleaseTree(CombatEventTree tree)
{
// clean buffer
queueBuffer.Clear();
queueBufferTail = 0;
//EB.Debug.LogError("ReleaseTree: queueBuffer start");
queueBuffer.Add(tree);
while (queueBuffer.Count - queueBufferTail > 0)
{
CombatEventTree front = queueBuffer[queueBufferTail++];
var iter = front.m_children.GetEnumerator();
while (iter.MoveNext())
{
var pair = iter.Current;
List <CombatEventTree> tree_list = pair.Value;
for (int i = 0, cnt = tree_list.Count; i < cnt; ++i)
{
queueBuffer.Add(tree_list[i]);
}
}
iter.Dispose();
}
for (int i = queueBuffer.Count - 1; i >= 0; --i)
{
CombatEventTree last = queueBuffer[i];
if (last.Parent != null)
{
last.Parent.RemoveChild(last);
}
last.RemoveAllChildren();
if (last.Event.Children != null)
{
last.Event.Children.Clear();
last.Event = null;
}
}
//EB.Debug.LogError("ReleaseTree: queueBuffer end");
queueBuffer.Clear();
queueBufferTail = 0;
}
public static bool IsTreeDone(CombatEventTree tree, CombatEventTree cut)
{
// clean buffer
queueBuffer.Clear();
queueBufferTail = 0;
//EB.Debug.LogError("IsTreeDone: queueBuffer start");
queueBuffer.Add(tree);
while (queueBuffer.Count - queueBufferTail > 0)
{
CombatEventTree front = queueBuffer[queueBufferTail++];
if (front == cut)
{
continue;
}
var iter = front.m_children.GetEnumerator();
while (iter.MoveNext())
{
var pair = iter.Current;
List <CombatEventTree> tree_list = pair.Value;
for (int i = 0, cnt = tree_list.Count; i < cnt; ++i)
{
queueBuffer.Add(tree_list[i]);
}
}
iter.Dispose();
if (front.NodeState != CombatEventTreeState.DONE)
{
//EB.Debug.LogError("IsTreeDone: queueBuffer end");
queueBuffer.Clear();
queueBufferTail = 0;
return(false);
}
}
//EB.Debug.LogError("IsTreeDone: queueBuffer end");
queueBuffer.Clear();
queueBufferTail = 0;
return(true);
}
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
if (obj == this)
{
return(true);
}
if (obj is CombatEventTree == false)
{
return(false);
}
CombatEventTree cmp_tree = obj as CombatEventTree;
return(m_event.GetUniqueCode() == cmp_tree.Event.GetUniqueCode());
}
public CombatEventTree Find(CombatEvent evt)
{
// speed up
CombatEventTree found = null;
if (s_nodeCache.TryGetValue(evt.GetHashCode(), out found))
{
if (found == this || found.IsAncestor(this))
{
return(found);
}
}
if (m_event.Equals(evt))
{
return(this);
}
EB.Debug.LogWarning("CombatEventTree.Find: cache miss");
var iter = m_children.GetEnumerator();
while (iter.MoveNext())
{
var pair = iter.Current;
List <CombatEventTree> tree_list = pair.Value;
for (int i = 0, cnt = tree_list.Count; i < cnt; ++i)
{
found = tree_list[i].Find(evt);
if (found != null)
{
iter.Dispose();
return(found);
}
}
}
iter.Dispose();
return(null);
}
public bool AddChild(CombatEventTree sub_tree)
{
if (sub_tree.Parent != null)
{
EB.Debug.LogError("AddChild: parent is set");
return(false);
}
eCombatEventTiming timing = sub_tree.Event.Timing;
if (!HasChildren(timing))
{
m_children[timing] = new List <CombatEventTree>();
}
List <CombatEventTree> children = GetChildren(timing);
if (ILRDefine.UNITY_EDITOR && children.Contains(sub_tree))
{
EB.Debug.LogError("AddChild: child exists");
return(false);
}
sub_tree.Parent = this;
children.Add(sub_tree);
if (ILRDefine.UNITY_EDITOR && s_nodeCache.ContainsKey(sub_tree.GetHashCode()))
{
EB.Debug.LogError("AddChild: cache exists");
}
s_nodeCache[sub_tree.GetHashCode()] = sub_tree;
if (ILRDefine.UNITY_EDITOR && timing == eCombatEventTiming.AUTO && children.Count > 1)
{
EB.Debug.LogError("AddChild: auto children great than one");
}
return(true);
}
public IEnumerable <CombatEventTree> GetSiblingsNonAlloc()
{
if (m_parent == null)
{
yield return(null);
}
var iter = m_parent.GetChildrenNonAlloc();
while (iter.MoveNext())
{
CombatEventTree sibling = iter.Current;
if (sibling == this)
{
continue;
}
yield return(sibling);
}
iter.Dispose();
}
private static List <CombatEventTree> TreeToList(CombatEventTree tree, CombatEventTree cut)
{
List <CombatEventTree> list = new List <CombatEventTree>();
queueBuffer.Clear();
queueBufferTail = 0;
//EB.Debug.LogError("TreeToList: queueBuffer start");
queueBuffer.Add(tree);
while (queueBuffer.Count - queueBufferTail > 0)
{
CombatEventTree front = queueBuffer[queueBufferTail++];
if (front == cut)
{
continue;
}
var iter = front.m_children.GetEnumerator();
while (iter.MoveNext())
{
var pair = iter.Current;
List <CombatEventTree> tree_list = pair.Value;
for (int i = 0, cnt = tree_list.Count; i < cnt; ++i)
{
queueBuffer.Add(tree_list[i]);
}
}
iter.Dispose();
list.Add(front);
}
//EB.Debug.LogError("TreeToList: queueBuffer end");
queueBuffer.Clear();
queueBufferTail = 0;
return(list);
}
public bool RemoveChild(CombatEventTree sub_tree)
{
if (sub_tree.Parent != this)
{
EB.Debug.LogError("RemoveChild: parent not match, this = {0}, target = {1}", Event.GetLogId(), sub_tree.Parent != null ? sub_tree.Parent.Event.GetLogId() : null);
return(false);
}
eCombatEventTiming timing = sub_tree.Event.Timing;
List <CombatEventTree> children = GetChildren(timing);
if (children == null)
{
EB.Debug.LogError("RemoveChild: timing not match, {0}", timing);
return(false);
}
if (!children.Remove(sub_tree))
{
EB.Debug.LogError("RemoveChild: child not found, {0}", sub_tree.Event.GetLogId());
return(false);
}
if (children.Count == 0 && !m_children.Remove(timing))
{
EB.Debug.LogError("RemoveChild: remove empty timing failed, {0}", timing);
return(false);
}
sub_tree.Parent = null;
if (ILRDefine.UNITY_EDITOR && !s_nodeCache.ContainsKey(sub_tree.GetHashCode()))
{
EB.Debug.LogError("RemoveChild: cache not exists");
}
s_nodeCache.Remove(sub_tree.GetHashCode());
return(true);
}
public bool RemoveChildren(eCombatEventTiming timing)
{
if (m_children.ContainsKey(timing))
{
List <CombatEventTree> children = GetChildren(timing);
int len = children.Count;
for (int i = 0; i < len; i++)
{
CombatEventTree child = children[i];
child.Parent = null;
if (ILRDefine.UNITY_EDITOR && !s_nodeCache.ContainsKey(child.GetHashCode()))
{
EB.Debug.LogError("RemoveChildren: cache not exists");
}
s_nodeCache.Remove(child.GetHashCode());
}
//children.Clear();
return(m_children.Remove(timing));
}
return(true);
}
public CombatEventTree FindInChildren(CombatEvent evt)
{
// speed up
CombatEventTree found = null;
if (s_nodeCache.TryGetValue(evt.GetHashCode(), out found))
{
if (found.IsAncestor(this))
{
return(found);
}
}
EB.Debug.LogWarning("CombatEventTree.FindInChildren: cache miss");
var iter = GetChildrenNonAlloc();
while (iter.MoveNext())
{
CombatEventTree child = iter.Current;
if (child.Event.Equals(evt))
{
iter.Dispose();
return(child);
}
found = child.FindInChildren(evt);
if (found != null)
{
iter.Dispose();
return(found);
}
}
iter.Dispose();
return(null);
}
public IEnumerator <CombatEventTree> GetParentsAndSiblingsNonAlloc(CombatEventTree cut)
{
if (m_parent == null)
{
yield break;
}
IEnumerator <CombatEventTree> list = TreeToListNonAlloc(m_parent, this);
while (list.MoveNext())
{
yield return(list.Current);
}
list.Dispose();
CombatEventTree from = m_parent;
var iter = m_parent.GetParentsNonAlloc();
while (iter.MoveNext())
{
CombatEventTree ancestor = iter.Current;
if (ancestor == cut)
{
break;
}
IEnumerator <CombatEventTree> ancestors = TreeToListNonAlloc(ancestor, from);
while (ancestors.MoveNext())
{
yield return(ancestors.Current);
}
ancestors.Dispose();
from = ancestor;
}
iter.Dispose();
}