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;
}
}
}
}
public void Dispose()
{
m_Elements.Clear();
m_Elements = null;
m_Childers = null;
m_Parent = null;
}
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);
}
internal Enumerator(hwmBetterList <T> list)
{
m_List = list;
m_Index = 0;
m_Version = m_List.m_Version;
Current = default(T);
}
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 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 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 bool MoveNext()
{
if (m_Version != m_List.m_Version)
{
throw new InvalidOperationException("list version invalid");
}
else
{
// Q: why use localList?
hwmBetterList <T> localList = m_List;
if ((uint)m_Index < (uint)localList.Count)
{
Current = localList.m_Items[m_Index++];
return(true);
}
else
{
m_Index = m_List.Count + 1;
Current = default(T);
return(false);
}
}
}
public void Dispose()
{
m_List = null;
Current = default(T);
}
