public void Dispose()
{
m_Foods.Clear();
m_Foods = null;
m_CreateEvents.Clear();
m_CreateEvents = null;
m_CreateEvents.Clear();
m_CreateEvents = null;
m_Quadtree.Dispose();
m_Quadtree = null;
m_FoodPool.Dispose();
m_FoodPool = null;
if (m_FoodPresentationPools != null)
{
for (int iFood = 0; iFood < m_FoodPresentationPools.Length; iFood++)
{
m_FoodPresentationPools[iFood].Dispose();
}
m_FoodPresentationPools = null;
}
Object.Destroy(m_FoodRoot);
}
public void DoUpdateCollide()
{
hwmBox2D collideAABB = hwmBox2D.BuildAABB(m_Head.GetPosition(), new Vector2(m_Head.Radius, m_Head.Radius));
hwmSphere2D headSphere = new hwmSphere2D(m_Head.GetPosition(), m_Properties.HeadColliderRadius);
if ((slConstants.DAMAGETYPE_WALL & m_EnableDamageType) != 0 &&
!slWorld.GetInstance().GetMap().GetMapBox().IsInsideOrOn(m_Head.AABB))
{
m_AliveState = AliveState.DeadHitWall;
return;
}
hwmQuadtree <QuadtreeElement> .AABBEnumerator enumerator = new hwmQuadtree <QuadtreeElement> .AABBEnumerator(m_Head.OwnerQuadtree.GetRootNode()
, collideAABB);
while (enumerator.MoveNext())
{
hwmQuadtree <QuadtreeElement> .Node iterNode = enumerator.Current;
hwmBetterList <QuadtreeElement> elements = iterNode.GetElements();
for (int iElement = elements.Count - 1; iElement >= 0; iElement--)
{
QuadtreeElement iterElement = elements[iElement];
if ((slConstants.DAMAGETYPE_SNAKE & m_EnableDamageType) != 0 &&
iterElement.Owner != m_Guid &&
iterElement.NodeType != slConstants.NodeType.Predict &&
(iterElement.GetPosition() - m_Head.GetPosition()).sqrMagnitude
<= ((m_Head.Radius + iterElement.Radius) * (m_Head.Radius + iterElement.Radius)))
{
m_AliveState = AliveState.DeadHitSnake;
}
}
}
}
protected bool IsHitPredict()
{
ms_SnakeQuadtreeNodes.Clear();
slWorld.GetInstance().GetSnakeSystem().GetQuadtree().GetRootNode()
.GetAllIntersectNode(ref ms_SnakeQuadtreeNodes, hwmBox2D.BuildAABB(m_Snake.GetHeadPosition(), new Vector2(m_Snake.GetHeadRadius(), m_Snake.GetHeadRadius())));
for (int iNode = 0; iNode < ms_SnakeQuadtreeNodes.Count; iNode++)
{
hwmQuadtree <slSnake.QuadtreeElement> .Node iterNode = ms_SnakeQuadtreeNodes[iNode];
hwmBetterList <slSnake.QuadtreeElement> elements = iterNode.GetElements();
for (int iElement = elements.Count - 1; iElement >= 0; iElement--)
{
slSnake.QuadtreeElement iterElement = elements[iElement];
if (iterElement.Owner != m_Snake.GetGuid() &&
iterElement.NodeType == slConstants.NodeType.Predict)
{
Vector2 predictCenter = iterElement.GetPosition();
Quaternion predictRotationInverse = Quaternion.Inverse(iterElement.GetRotation());
Vector2 sphereCenter = predictCenter
+ hwmMath.QuaternionMultiplyVector(predictRotationInverse, (Vector2)m_Snake.GetHeadPosition() - predictCenter);
if (((slSnake.PredictNode)iterElement).Box.IntersectSphere(sphereCenter, m_Snake.GetHeadRadius() * m_Snake.GetHeadRadius()))
{
return(true);
}
}
}
}
return(false);
}
public void DoDrawGizmos()
{
if (m_Current != null)
{
hwmQuadtree <T> .Node gizmosNode = GetDisplayNode();
Gizmos.color = m_GizmosColor;
hwmUtility.GizmosDrawBox2D(gizmosNode.GetLooseBox(), m_GizmosZ);
DoDrawGizomsElements(gizmosNode);
}
}
public QuadtreeGizmosEnumerator(hwmQuadtree <T> quadtree)
{
m_Quadtree = quadtree;
m_Current = m_Quadtree.GetRootNode();
m_GizmosColor = Color.black;
m_GizmosZ = 0;
m_GizomosDisplayChilderElement = true;
m_LastNodes = new Stack <hwmQuadtree <T> .Node>();
m_ChilderIndex = NOTSET_CHILDER_INDEX;
}
public NodePool(slSnakePresentationProperties presentation, Transform root, hwmQuadtree <slSnake.QuadtreeElement> quadtree)
{
m_Presentation = presentation;
m_Root = root;
m_Quadtree = quadtree;
Type nodeType = typeof(T);
m_NodeType = nodeType == typeof(slSnake.HeadNode)
? slConstants.NodeType.Head
: nodeType == typeof(slSnake.ClothesNode)
? slConstants.NodeType.Clothes
: slConstants.NodeType.Body;
}
public void Initialize(hwmQuadtree <T> owner, Node parent, hwmBox2D box, hwmQuadtreeChilderNodeIndex indexInParent)
{
bool isRoot = parent == null;
m_Owner = owner;
m_Parent = parent;
m_IndexInParent = indexInParent;
m_Box = box;
m_LooseBox = new hwmBox2D(m_Box.Min - m_Owner.m_LooseSize, m_Box.Max + m_Owner.m_LooseSize);
m_IsLeaf = true;
m_Depth = isRoot ? 1 : parent.m_Depth + 1;
m_Elements = new hwmBetterList <T>();
}
public void Initialize(slLevel level)
{
m_FoodRoot = new GameObject("Foods").transform;
m_FoodMaxPosition = level.MapSize * 0.5f - new Vector2(slConstants.FOOD_MAP_EDGE, slConstants.FOOD_MAP_EDGE);
m_FoodMinPosition = -m_FoodMaxPosition;
m_MaxFood = level.FoodCount;
m_FoodPropertiess = new slFoodProperties[(int)slConstants.FoodType.Count];
for (int iFood = 0; iFood < m_FoodPropertiess.Length; iFood++)
{
m_FoodPropertiess[iFood] = hwmSystem.GetInstance().GetAssetLoader().LoadAsset(hwmAssetLoader.AssetType.Game
, slConstants.FOOD_PROPERTIES_PREFAB_STARTWITHS + slConstants.FoodTypeToString((slConstants.FoodType)iFood)) as slFoodProperties;
}
m_Quadtree = new hwmQuadtree <slFood>();
m_Quadtree.Initialize(CalculateQuadtreeDepth()
, slConstants.FOOD_QUADTREE_MAXELEMENT_PERNODE
, slConstants.FOOD_QUADTREE_MINELEMENT_PREPARENTNODE
, new Vector2(slConstants.FOOD_QUADTREE_LOOSESIZE, slConstants.FOOD_QUADTREE_LOOSESIZE)
, slWorld.GetInstance().GetMap().GetMapBox());
#if UNITY_EDITOR
slQuadtreeGizmos.FoodQuadtree = m_Quadtree;
#endif
m_FoodPool = new FoodPool(m_FoodRoot);
m_FoodPool.Initialize(Mathf.CeilToInt(m_MaxFood * slConstants.FOOD_POOL_INITIALIZE_MULTIPLY));
if (slWorld.GetInstance().NeedPresentation())
{
m_FoodPresentationPools = new FoodPresentationPool[(int)slConstants.FoodType.Count];
for (int iFood = 0; iFood < m_FoodPropertiess.Length; iFood++)
{
slConstants.FoodType foodType = (slConstants.FoodType)iFood;
m_FoodPresentationPools[iFood] = new FoodPresentationPool(m_FoodRoot, foodType);
m_FoodPresentationPools[iFood].Initialize(0);
}
}
m_CreateEvents = new Queue <CreateEvent>();
m_Foods = new hwmBetterDictionary <int, slFood>();
m_DestroyEvents = new hwmBetterList <slFood>();
m_FoodCount = 0;
}
protected bool IsSafe(Vector2 moveDirection, float distance, bool ignorePredict)
{
Vector2 start = m_Snake.GetHeadPosition();
Vector2 end = start + moveDirection * distance;
Vector2 direction = end - start;
Vector2 directionReciprocal = hwmMath.Reciprocal(direction);
if (!slWorld.GetInstance().GetMap().GetMapBox().IsInsideOrOn(end))
{
return(false);
}
for (int iNode = 0; iNode < ms_SnakeQuadtreeNodes.Count; iNode++)
{
hwmQuadtree <slSnake.QuadtreeElement> .Node iterNode = ms_SnakeQuadtreeNodes[iNode];
hwmBetterList <slSnake.QuadtreeElement> elements = iterNode.GetElements();
for (int iElement = elements.Count - 1; iElement >= 0; iElement--)
{
slSnake.QuadtreeElement iterElement = elements[iElement];
if (iterElement.Owner != m_Snake.GetGuid())
{
if (iterElement.NodeType != slConstants.NodeType.Predict)
{
if (iterElement.AABB.LineIntersection(start, end, direction, directionReciprocal))
{
return(false);
}
}
else if (!ignorePredict)
{
Quaternion rotation = Quaternion.Inverse(iterElement.GetRotation());
Vector2 center = iterElement.GetPosition();
start = hwmMath.QuaternionMultiplyVector(rotation, start - center);
end = hwmMath.QuaternionMultiplyVector(rotation, end - center);
if (((slSnake.PredictNode)iterElement).Box.LineIntersection(start, end))
{
return(false);
}
}
}
}
}
return(true);
}
private void OnGUI_ChildersButton(hwmQuadtreeChilderNodeIndex index)
{
if (m_Current.IsLeaf())
{
GUILayout.Button("No " + index.ToString());
}
else if (GUILayout.Button(index.ToString()))
{
if (m_ChilderIndex == index) // double click enter childer
{
m_LastNodes.Push(m_Current);
m_Current = m_Current.GetChilder(m_ChilderIndex);
m_ChilderIndex = NOTSET_CHILDER_INDEX;
}
else
{
m_ChilderIndex = index;
}
}
}
private void DoDrawGizomsElements(hwmQuadtree <T> .Node node)
{
if (node == null)
{
return;
}
hwmBetterList <T> elements = node.GetElements();
for (int iElement = 0; iElement < elements.Count; iElement++)
{
hwmUtility.GizmosDrawBox2D(elements[iElement].AABB, m_GizmosZ);
}
if (m_GizomosDisplayChilderElement && !node.IsLeaf())
{
DoDrawGizomsElements(node.GetChilder(hwmQuadtreeChilderNodeIndex.LeftDown));
DoDrawGizomsElements(node.GetChilder(hwmQuadtreeChilderNodeIndex.LeftUp));
DoDrawGizomsElements(node.GetChilder(hwmQuadtreeChilderNodeIndex.RightUp));
DoDrawGizomsElements(node.GetChilder(hwmQuadtreeChilderNodeIndex.RightDown));
}
}
public void Initialize()
{
m_PoolRoot = new GameObject("Snakes").transform;
m_SnakeNameToIndex = new Dictionary <string, int>();
m_TweakablePropertiess = new Dictionary <string, slSnakeTweakableProperties>();
m_Propertiess = new List <slSnakeProperties>();
m_HeadPools = new List <NodePool <slSnake.HeadNode> >();
m_ClothesNodePools = new List <NodePool <slSnake.ClothesNode> >();
m_BodyPools = new List <NodePool <slSnake.BodyNode> >();
m_Quadtree = new hwmQuadtree <slSnake.QuadtreeElement>();
m_Quadtree.Initialize(CalculateQuadtreeDepth()
, slConstants.SNAKE_QUADTREE_MAXELEMENT_PERNODE
, slConstants.SNAKE_QUADTREE_MINELEMENT_PREPARENTNODE
, new Vector2(slConstants.SNAKE_QUADTREE_LOOSESIZE, slConstants.SNAKE_QUADTREE_LOOSESIZE)
, slWorld.GetInstance().GetMap().GetMapBox());
m_Quadtree.AutoMergeAndSplitNode = false;
#if UNITY_EDITOR
slQuadtreeGizmos.SnakeQuadtree = m_Quadtree;
#endif
}
public void EatFood(float radius)
{
ms_FoodQuadtreeNodes.Clear();
hwmBox2D eatAABB = hwmBox2D.BuildAABB(m_Head.GetPosition(), new Vector2(radius, radius));
slWorld.GetInstance().GetFoodSystem().GetQuadtree().GetRootNode().GetAllIntersectNode(ref ms_FoodQuadtreeNodes, eatAABB);
hwmSphere2D headSphere = new hwmSphere2D(m_Head.GetPosition(), radius);
for (int iNode = 0; iNode < ms_FoodQuadtreeNodes.Count; iNode++)
{
hwmQuadtree <slFood> .Node iterNode = ms_FoodQuadtreeNodes[iNode];
hwmBetterList <slFood> foods = iterNode.GetElements();
bool inHeadSphere = headSphere.IsInside(iterNode.GetLooseBox());
for (int iFood = foods.Count - 1; iFood >= 0; iFood--)
{
slFood iterFood = foods[iFood];
if (inHeadSphere ||
(iterFood.GetPosition() - m_Head.GetPosition()).sqrMagnitude <= radius * radius)
{
EatFood(iterFood);
}
}
}
}
public void OnGUI()
{
while (m_Current == null)
{
if (m_LastNodes.Count > 0)
{
m_Current = m_LastNodes.Pop();
}
else
{
m_Current = m_Quadtree.GetRootNode();
break;
}
}
if (m_Current == null)
{
EditorGUILayout.HelpBox("not found any node", MessageType.Error);
return;
}
hwmQuadtree <T> .Node displayNode = GetDisplayNode();
EditorGUILayout.LabelField("Depth:", displayNode.GetDepth().ToString());
EditorGUILayout.LabelField("Element Count:", displayNode.GetElements().Count.ToString());
EditorGUILayout.LabelField("Element Count In Self&Childers :", displayNode.GetAllElementCount().ToString());
EditorGUILayout.Space();
if (m_Current.GetParent() == null &&
m_ChilderIndex == NOTSET_CHILDER_INDEX)
{
GUILayout.Button("No Parent");
}
else if (GUILayout.Button("Parent"))
{
if (m_ChilderIndex != NOTSET_CHILDER_INDEX)
{
m_ChilderIndex = NOTSET_CHILDER_INDEX;
}
else
{
m_Current = m_LastNodes.Pop();
}
}
EditorGUILayout.BeginHorizontal();
OnGUI_ChildersButton(hwmQuadtreeChilderNodeIndex.LeftUp);
OnGUI_ChildersButton(hwmQuadtreeChilderNodeIndex.RightUp);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
OnGUI_ChildersButton(hwmQuadtreeChilderNodeIndex.LeftDown);
OnGUI_ChildersButton(hwmQuadtreeChilderNodeIndex.RightDown);
EditorGUILayout.EndHorizontal();
if (m_Current.IsLeaf() || m_ChilderIndex == NOTSET_CHILDER_INDEX)
{
GUILayout.Button("Cant Enter Childer");
}
else if (GUILayout.Button("Enter Childer: " + m_ChilderIndex.ToString()))
{
m_LastNodes.Push(m_Current);
m_Current = m_Current.GetChilder(m_ChilderIndex);
m_ChilderIndex = NOTSET_CHILDER_INDEX;
}
EditorGUILayout.Space();
EditorGUILayout.LabelField("Gizmos");
m_GizmosColor = EditorGUILayout.ColorField("Color", m_GizmosColor);
m_GizmosZ = EditorGUILayout.FloatField("Z", m_GizmosZ);
m_GizomosDisplayChilderElement = EditorGUILayout.Toggle("Display Childer Element", m_GizomosDisplayChilderElement);
if (GUI.changed)
{
GetWindow <SceneView>().Focus();
}
}
public void Dispose()
{
m_Quadtree = null;
m_Current = null;
m_LastNodes = null;
}
