private AssetNode GetAssetNodeSync(string assetPath)
{
if (assetNodeDic.TryGetValue(assetPath, out var assetNode))
{
if (assetNode.IsLoaded())
{
return(assetNode);
}
else
{
if (operationLDic.TryGetValue(assetPath, out var operation))
{
throw new Exception();
}
else
{
assetNode.SetAsset(RequestAssetSync(assetPath));
return(assetNode);
}
}
}
assetNode = assetNodePool.Get();
assetNode.DoInitialize(assetPath);
assetNode.SetAsset(RequestAssetSync(assetPath));
OnCreateAssetNodeSync(assetNode);
assetNodeDic.Add(assetPath, assetNode);
return(assetNode);
}
private BundleNode GetBundleNode(string bundlePath)
{
if (bundleNodeDic.TryGetValue(bundlePath, out var bundleNode))
{
if (bundleNode.IsDone)
{
return(bundleNode);
}
else
{
throw new Exception("");
}
}
BundleNode mainBundleNode = bundleNodePool.Get();
string[] dependBundlePaths = bundleDetailConfig.GetDependencies(bundlePath);
for (int i = 0; i < dependBundlePaths.Length; i++)
{
BundleNode dependBundleNode = GetBundleNode(dependBundlePaths[i]);
mainBundleNode.BindDepend(dependBundleNode);
}
AssetBundle bundle = LoadBundleFromFile(bundlePath);
mainBundleNode.Bundle = bundle;
bundleNodeDic.Add(bundlePath, mainBundleNode);
return(mainBundleNode);
}
protected override void OnAsyncRequestUpdate(AsyncRequest request)
{
var result = request.result;
string[] assetPaths = request.paths;
for (int i = 0; i < assetPaths.Length; i++)
{
if (result.IsDoneAt(i))
{
continue;
}
string assetPath = assetPaths[i];
AssetNode assetNode = assetNodeDic[assetPath];
if (assetNode.IsLoaded())
{
if (request.isInstance)
{
request.SetUObject(i, assetNode.CreateInstance());
}
else
{
request.SetUObject(i, assetNode.GetAsset());
}
assetNode.ReleaseRef();
continue;
}
else
{
string bundlePath = assetDetailConfig.GetBundleByPath(assetPath);
BundleNode bundleNode = bundleNodeDic[bundlePath];
if (bundleNode.IsDone && !assetOperationDic.ContainsKey(assetPath))
{
BundleAssetAsyncOperation assetOperation = assetOperationPool.Get();
assetOperation.DoInitilize(assetPath);
assetOperation.OnOperationComplete = OnAssetFromBundleCreated;
assetOperationDic.Add(assetPath, assetOperation);
operationLDic.Add(assetPath, assetOperation);
}
request.SetProgress(i, GetAsyncAssetProgress(assetPath));
}
}
if (result.IsDone())
{
if (request.isInstance)
{
request.state = RequestState.InstanceFinished;
}
else
{
request.state = RequestState.LoadFinished;
}
}
}
public void OnMessageReceived(byte[] dataBytes)
{
lock (receviedMessageList)
{
if (messageDecoder.Decode(dataBytes, out int messageId, out byte[] body))
{
ClientReceviedMessage receviedMessage = receviedMessagePool.Get();
receviedMessage.Id = messageId;
receviedMessage.Body = body;
receviedMessageList.Add(receviedMessage);
}
protected override void OnAsyncRequestUpdate(AsyncRequest request)
{
var result = request.result;
string[] assetPaths = request.paths;
for (int i = 0; i < assetPaths.Length; i++)
{
if (result.IsDoneAt(i))
{
continue;
}
string assetPath = assetPaths[i];
AssetNode assetNode = assetNodeDic[assetPath];
if (assetNode.IsLoaded())
{
if (request.isInstance)
{
request.SetUObject(i, assetNode.CreateInstance());
}
else
{
request.SetUObject(i, assetNode.GetAsset());
}
assetNode.ReleaseRef();
continue;
}
else
{
if (!operationLDic.TryGetValue(assetPath, out var assetOperation))
{
assetOperation = assetOperationPool.Get();
assetOperation.DoInitilize(assetPath);
assetOperation.OnOperationComplete = OnAssetLoadCompleted;
operationLDic.Add(assetPath, assetOperation);
}
request.SetProgress(i, assetOperation.Progress);
}
}
if (result.IsDone())
{
if (request.isInstance)
{
request.state = RequestState.InstanceFinished;
}
else
{
request.state = RequestState.LoadFinished;
}
}
}
public void OnMessageReceived(Guid guid, byte[] dataBytes)
{
if (messageDecoder.Decode(dataBytes, out int messageId, out byte[] messageBody))
{
lock (receviedMessageList)
{
ServerReceivedMessage receviedMessage = receviedMessagePool.Get();
receviedMessage.SessionId = guid;
receviedMessage.MessageId = messageId;
receviedMessage.MessageBody = messageBody;
receviedMessageList.Add(receviedMessage);
}
}
public void DropPowerUp()
{
if (ItemPool && UnityEngine.Random.Range(0f, 1f) > 0.1f && !powerUpDroped)
{
powerUpDroped = true;
var powerUp = ItemPool.Get();
if (powerUp == null)
{
return;
}
powerUp.Spawn(transform.position);
ItemPool.AddItem(powerUp);
}
}
//结点达到分裂的限定，进行结点的分裂
private void SplitNode(QuadNode node)
{
AABB2D bounds = node.Bounds;
Vector2 childNodeExtents = bounds.HalfExtents;
QuadNode childNode = m_NodePool.Get();
childNode.SetData(node.Depth + 1, QuadNodeDirection.LB, new AABB2D(bounds.Center - childNodeExtents, childNodeExtents));
node[QuadNodeDirection.LB] = childNode;
childNode = m_NodePool.Get();
childNode.SetData(node.Depth + 1, QuadNodeDirection.RB, new AABB2D(bounds.Center + new Vector2(childNodeExtents.x, -childNodeExtents.y), childNodeExtents));
node[QuadNodeDirection.RB] = childNode;
childNode = m_NodePool.Get();
childNode.SetData(node.Depth + 1, QuadNodeDirection.LT, new AABB2D(bounds.Center + new Vector2(-childNodeExtents.x, childNodeExtents.y), childNodeExtents));
node[QuadNodeDirection.LT] = childNode;
childNode = m_NodePool.Get();
childNode.SetData(node.Depth + 1, QuadNodeDirection.RT, new AABB2D(bounds.Center + childNodeExtents, childNodeExtents));
node[QuadNodeDirection.RT] = childNode;
}
private BundleNode CreateAsyncBundleNode(string bundlePath)
{
var bundleNode = bundleNodePool.Get();
bundleNode.State = NodeState.Loading;
BundleAsyncOperation bundleOperation = bundleOperationPool.Get();
bundleOperation.DoInitilize(bundlePath, bundleRootDir);
bundleOperation.OnOperationComplete = OnBundleCreated;
bundleOperationDic.Add(bundlePath, bundleOperation);
operationLDic.Add(bundlePath, bundleOperation);
bundleNodeDic.Add(bundlePath, bundleNode);
return(bundleNode);
}
private int RequestAssetsAsync(
string[] addresses,
string[] paths,
bool isInstance,
OnAssetProgress progressCallback,
OnAssetComplete completeCallback,
OnAssetsProgress progressesCallback,
OnAssetsComplete completesCallback,
AsyncPriority priority,
SystemObject userdata)
{
int id = uniqueIDCreator.GetNextID();
AsyncRequest request = requestPool.Get();
request.id = id;
request.addresses = addresses;
request.paths = paths;
request.isInstance = isInstance;
request.progressCallback = progressCallback;
request.completeCallback = completeCallback;
request.progressesCallback = progressesCallback;
request.completesCallback = completesCallback;
request.priority = priority;
request.userdata = userdata;
request.state = RequestState.WaitingForStart;
AsyncResult result = resultPool.Get();
result.DoInitialize(id, addresses);
resultDic.Add(id, result);
request.result = result;
requestDic.Add(id, request);
waitingRequestQueue.Enqueue(request, request.priority);
return(id);
}
