/// <summary>
/// Tells the collisionsystem to check all bodies for collisions. Hook into the
/// <see cref="CollisionSystem.PassedBroadphase"/>
/// and <see cref="CollisionSystem.CollisionDetected"/> events to get the results.
/// </summary>
public override void Detect()
{
if (addCounter > AddedObjectsBruteForceIsUsed)
{
for (int i = 0, length = fullOverlaps.Count; i < length; i++)
{
OverlapPair.Pool.GiveBack(fullOverlaps[i]);
}
fullOverlaps.Clear();
DirtySortAxis(axis1);
DirtySortAxis(axis2);
DirtySortAxis(axis3);
}
else
{
sortCallback(axis1);
sortCallback(axis2);
sortCallback(axis3);
}
addCounter = 0;
foreach (OverlapPair key in fullOverlaps)
{
if (this.CheckBothStaticNonKinematic(key.Entity1, key.Entity2))
{
continue;
}
if (base.RaisePassedBroadphase(key.Entity1, key.Entity2))
{
Detect(key.Entity1, key.Entity2);
}
}
}
public void ClearContentTriggers()
{
lock (_triggerContent)
{
_triggerContent.Clear();
}
}
public void ClearResponses()
{
lock (_responses)
{
_responses.Clear();
}
}
public void ClearCardTriggers()
{
lock (_triggerCards)
{
_triggerCards.Clear();
}
}
public void VersionCheck_Clear()
{
var list = new HashList <int>();
IEnumerator enumerator = list.GetEnumerator();
list.Clear();
try
{
enumerator.MoveNext();
Assert.Fail("#1");
}
catch (InvalidOperationException)
{
}
try
{
enumerator.Reset();
Assert.Fail("#2");
}
catch (InvalidOperationException)
{
}
enumerator = list.GetEnumerator();
enumerator.MoveNext();
}
void ReCreateAlerts()
{
foreach (var alert in ActiveItems)
{
GOPool.Despawn(alert.gameObject);
}
ActiveItems.Clear();
if (delayCallTask != null)
{
BattleCoroutine.Kill(delayCallTask);
}
delayCallTask = BattleCoroutine.Run(AddInitAlerts());
IEnumerator <float> AddInitAlerts()
{
if (AlertMgr != null)
{
for (int i = 0; i < AlertMgr.Data.Count; ++i)
{
if (i >= AlertMgr.Data.Count)
{
yield break;
}
yield return(Timing.WaitForSeconds(0.1f));
AddAlert(AlertMgr.Data[i]);
}
}
yield break;
}
}
public static void ClearAllCachedAttributes()
{
try
{
BaseClass = string.Empty;
ClassName = string.Empty;
if (HashClassGUID != null)
{
HashClassGUID.Clear();
}
if (HashList != null)
{
HashList.Clear();
}
if (HashTableBaseClass != null)
{
HashTableBaseClass.Clear();
}
if (OMResultedQuery != null)
{
OMResultedQuery.Clear();
}
QueryResultToolWindow = null;
Tab_index = 0;
ListofModifiedObjects.Instance.Clear();
}
catch (Exception oEx)
{
LoggingHelper.ShowMessage(oEx);
}
}
/// <summary>
/// Tells the collisionsystem to check all bodies for collisions. Hook into the
/// <see cref="CollisionSystem.PassedBroadphase"/>
/// and <see cref="CollisionSystem.CollisionDetected"/> events to get the results.
/// </summary>
public override void Detect()
{
if (addCounter > AddedObjectsBruteForceIsUsed)
{
fullOverlaps.Clear();
DirtySortAxis(axis1);
DirtySortAxis(axis2);
DirtySortAxis(axis3);
}
else
{
sortCallback(axis1);
sortCallback(axis2);
sortCallback(axis3);
}
addCounter = 0;
for (int index = 0, length = fullOverlaps.Count; index < length; index++)
{
OverlapPair pair = fullOverlaps[index];
if (this.CheckBothStaticNonKinematic(pair.Entity1, pair.Entity2))
{
continue;
}
if (base.RaisePassedBroadphase(pair.Entity1, pair.Entity2))
{
Detect(pair.Entity1, pair.Entity2);
}
}
}
private void Rebuild()
{
HashList <T> l = new HashList <T>();
l.AddRange(_items.Where(a => !a.IsDeleted));
l.AddRange(Secondary.Where(a => !a.IsDeleted));
Secondary.Clear();
Populate(l);
_grow = 0;
_degrow = 0;
}
/// <summary>
/// Removes all objects from the world and removes all memory cached objects.
/// </summary>
public void Clear()
{
// remove bodies from collision system
for (int index = 0, length = rigidBodies.Count; index < length; index++)
{
RigidBody body = rigidBodies[index];
CollisionSystem.RemoveEntity(body);
if (body.island != null)
{
body.island.ClearLists();
body.island = null;
}
body.connections.Clear();
body.arbiters.Clear();
body.constraints.Clear();
events.RaiseRemovedRigidBody(body);
}
for (int index = 0, length = softbodies.Count; index < length; index++)
{
SoftBody body = softbodies[index];
CollisionSystem.RemoveEntity(body);
}
// remove bodies from the world
rigidBodies.Clear();
// remove constraints
for (int index = 0, length = constraints.Count; index < length; index++)
{
Constraint constraint = constraints[index];
events.RaiseRemovedConstraint(constraint);
}
constraints.Clear();
softbodies.Clear();
// remove all islands
islands.RemoveAll();
// delete the arbiters
arbiterMap.Clear();
arbiterTriggerMap.Clear();
ResetResourcePools();
}
protected override void OnSetPlayerBase(BaseUnit oldPlayer, BaseUnit newPlayer)
{
base.OnSetPlayerBase(oldPlayer, newPlayer);
if (AlertMgr != null)
{
AlertMgr.Callback_OnAdded -= OnAlertAdded;
AlertMgr.Callback_OnRemoved -= OnAlertRemoved;
AlertMgr.Callback_OnMerge -= OnAlertMerge;
AlertMgr.Callback_OnCommingTimeOut -= OnAlertCommingTimeOut;
}
AlertMgr = NewAlertMgr;
AlertMgr.Callback_OnAdded += OnAlertAdded;
AlertMgr.Callback_OnRemoved += OnAlertRemoved;
AlertMgr.Callback_OnMerge += OnAlertMerge;
AlertMgr.Callback_OnCommingTimeOut += OnAlertCommingTimeOut;
AlertDatasSet.Clear();
ReCreateAlerts();
}
/// <summary>
/// Tells the collisionsystem to check all bodies for collisions. Hook into the
/// 告诉碰撞系统检查所有碰撞物体。
/// <see cref="CollisionSystem.PassedBroadphase"/>
/// and <see cref="CollisionSystem.CollisionDetected"/> events to get the results.
/// </summary>
public override void Detect()
{
if (addCounter > AddedObjectsBruteForceIsUsed)
{
fullOverlaps.Clear();
DirtySortAxis(axis1);
DirtySortAxis(axis2);
DirtySortAxis(axis3);
}
else
{
sortCallback(axis1);
sortCallback(axis2);
sortCallback(axis3);
}
addCounter = 0;
foreach (OverlapPair key in fullOverlaps)
{
if (this.CheckBothStaticNonKinematic(key.Entity1, key.Entity2))
{
continue;
}
if (base.RaisePassedBroadphase(key.Entity1, key.Entity2))
{
if (swapOrder)
{
Detect(key.Entity1, key.Entity2);
}
else
{
Detect(key.Entity2, key.Entity1);
}
swapOrder = !swapOrder;
}
}
}
private void Update()
{
ScreenLog.SetSticky("Update", update.Count.ToString());
if (update.Count == 0)
{
return;
}
foreach (var redraw in update)
{
if (chunks.ContainsKey(redraw))
{
continue;
}
CreateChunk(redraw);
}
foreach (var redraw in update)
{
chunks[redraw].UpdateChunk();
}
update.Clear();
}
internal void Clear()
{
keysSortedList.Clear();
dictionaryKeys.Clear();
}
public void Tick()
{
if (changes.Count == 0)
{
return;
}
tick++;
// go through all changes made
foreach (var change in changes)
{
// find each change's area
var area = change / 8;
List <AreaHistory> steps;
if (!history.TryGetValue(area, out steps))
{
steps = new List <AreaHistory>();
steps.Add(new AreaHistory(tick));
history.Add(area, steps);
}
// if area doesn't already have a history for this tick: create one
if (steps[steps.Count - 1].time < tick)
{
// if we have 10 history entries for this area merge the last two together
// and reuse one as the new top entry. Else add a new top entry.
if (steps.Count >= 10)
{
var swap = steps[1];
steps.RemoveAt(1);
steps[0].changes.AddRange(swap.changes);
steps[0].time = swap.time;
swap.changes.Clear();
swap.time = tick;
steps.Add(swap);
}
else
{
steps.Add(new AreaHistory(tick));
}
}
// make sure that each change is only represented at ONE history step
for (int i = 0; i < steps.Count; i++)
{
if (steps[i].changes.Remove(change))
{
break;
}
}
// add the change to the top history step
steps[steps.Count - 1].changes.Add(change);
}
changes.Clear();
for (int i = 0; i < players.Count; i++)
{
for (int j = 0; j < Vint3.Offset.Length; j++)
{
var a = players[i].area + Vint3.Offset[j];
SendArea(players[i], a);
}
}
}
public virtual void RemoveAll()
{
base.Clear();
HashList.Clear();
}
public void CleanUp()
{
bodies.Clear();
arbiter.Clear();
constraints.Clear();
}
/// <summary>
/// Calculate the route from start to end.
/// </summary>
/// <param name="start">Start.</param>
/// <param name="end">End.</param>
public void Route(T start, T end, List <T> route)
{
route.Clear();
if (start == null || end == null)
{
return;
}
for (int i = 0, nodesLength = nodes.Length; i < nodesLength; i++)
{
var s = nodes[i];
g[s] = 0f;
parent[s] = null;
inPath[s] = false;
}
openset.Clear();
closedset.Clear();
path.Clear();
var current = start;
openset.Add(current);
while (openset.Count > 0)
{
current = openset[0];
for (var i = 1; i < openset.Count; i++)
{
var d = g[current].CompareTo(g[openset[i]]);
if (d < 0)
{
current = openset[i];
}
}
//openset.Sort ((a,b) => g [a].CompareTo (g [b]));
current = openset[0];
if (current == end)
{
while (parent[current] != null)
{
path.Enqueue(current);
inPath[current] = true;
current = parent[current];
if (path.Count >= nodes.Length)
{
return;
}
}
inPath[current] = true;
path.Enqueue(current);
while (path.Count > 0)
{
route.Add(path.Dequeue());
}
return;
}
openset.Remove(current);
closedset.Add(current);
var connectedNodes = current.GetConnectedNodes();
for (int i = 0, connectedNodesCount = connectedNodes.Count; i < connectedNodesCount; i++)
{
var node = connectedNodes[i];
if (closedset.Contains(node))
{
continue;
}
if (openset.Contains(node))
{
var new_g = g[current] + current.CalculateMoveCost(node);
if (g[node] > new_g)
{
g[node] = new_g;
parent[node] = current;
}
}
else
{
g[node] = g[current] + current.CalculateMoveCost(node);
parent[node] = current;
openset.Add(node);
}
}
}
return;
}
