public virtual void LoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadError)
{
int objectsToLoad = _loadables.Count;
int objectsLoaded = 0;
bool hasError = false;
LoadSuccess onComplete = () =>
{
if (++objectsLoaded >= objectsToLoad)
{
onLoadSuccess();
}
};
LoadError onError = (e) =>
{
if (!hasError)
{
onLoadError(e);
}
hasError = true;
};
if (_loadables.Count == 0)
{
TaskProvider.Instance.DelayedAction(() => onComplete());
}
else
{
foreach (ILoadableObject loadable in _loadables)
{
loadable.LoadAsync(onComplete, onError);
}
}
}
public void LoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadFailed)
{
LoaderGroup loaderGroup = new LoaderGroup();
PopulatedLoadGroup(loaderGroup);
loaderGroup.LoadAsync(onLoadSuccess, onLoadFailed);
}
public void LoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadError)
{
try
{
// Load asset from assetBundle.
string fileName = System.IO.Path.GetFileNameWithoutExtension(_path);
AssetBundleLoadAssetOperation request = AssetBundleManager.LoadAssetAsync(_bundle, fileName, typeof(UnityEngine.Object));
if (request == null)
{
return;
}
TaskProvider.Instance.RunTask(request, () =>
{
_asset = request.GetAsset <UnityEngine.Object>();
IsLoaded = true;
if (_asset is ILoadableObject)
{
(_asset as ILoadableObject).LoadAsync(onLoadSuccess, onLoadError);
}
else
{
onLoadSuccess();
}
});
}
catch (Exception e)
{
onLoadError(new LoadException(e.ToString(), e));
}
}
public void LoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadError)
{
_action.Invoke(() =>
{
IsLoaded = true;
onLoadSuccess();
}, onLoadError);
}
protected override void InternalLoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadFailed)
{
LoadSourceDataAsync((source) =>
{
PopulateData(source, ref _dataLookup);
onLoadSuccess();
}, onLoadFailed);
}
public void LoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadError)
{
List <LoaderGroup> .Enumerator groups = _groups.GetEnumerator();
if (groups.MoveNext())
{
groups.Current.LoadAsync(() => { GroupLoaded(groups, onLoadSuccess, onLoadError); }, onLoadError);
}
else
{
TaskProvider.Instance.DelayedAction(() => onLoadSuccess());
}
}
public void LoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadFailed)
{
LoaderGroup loaderGroup = new LoaderGroup();
loaderGroup.AppendProvider(_loaderGroup);
PopulatedLoadGroup(loaderGroup);
loaderGroup.LoadAsync(() =>
{
IsLoaded = true;
onLoadSuccess();
}, onLoadFailed);
}
private void GroupLoaded(List <LoaderGroup> .Enumerator groups, LoadSuccess onLoadSuccess, LoadError onLoadError)
{
if (groups.MoveNext())
{
groups.Current.LoadAsync(() => { GroupLoaded(groups, onLoadSuccess, onLoadError); }, onLoadError);
}
else
{
groups.Dispose();
TaskProvider.Instance.DelayedAction(() => onLoadSuccess());
}
}
protected override void InternalLoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadFailed)
{
try
{
_pandeaGameConfigurationData = Resources.Load <PandeaGameConfigurationData>(PandeaGameConfigurationDataPath);
_pandeaGameConfigurationData.LoadAsync(onLoadSuccess, onLoadFailed);
}
catch (Exception e)
{
onLoadFailed(new LoadException("Failed to load game data.", e));
throw;
}
}
private void DoLoad(LoadSuccess onLoadSuccess, LoadError onLoadError, int i)
{
_loadables[i].LoadAsync(() =>
{
i++;
if (i < _loadables.Count)
{
DoLoad(onLoadSuccess, onLoadError, i);
}
else
{
onLoadSuccess();
}
}, onLoadError);
}
public void LoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadFailed)
{
if (_list != null)
{
int loaded = 0;
_list.ForEach((weakReference) =>
{
weakReference.LoadAssetAsync <T>((data, reference) =>
{
if (++loaded >= _list.Count)
{
IsLoaded = true;
onLoadSuccess();
}
}, (exception) => { onLoadFailed(new LoadException("Failed to load asset in list.", exception)); });
});
}
}
public void LoadAsync(LoadSuccess onComplete, LoadError onError)
{
WeakReference[] weakReferences = WeakReferences();
int assetCount = weakReferences.Length;
int totalLoadsRequired = assetCount + 1;
int loadsCompleted = 0;
bool hasFailed = false;
Action <WeakReference> assetLoaded = (reference) =>
{
if (++loadsCompleted >= totalLoadsRequired)
{
onComplete();
}
};
LoadSuccess adjunctLoaded = () =>
{
if (++loadsCompleted >= totalLoadsRequired)
{
onComplete();
}
};
Action <WeakReferenceException> assetLoadFailed = (e) =>
{
if (!hasFailed)
{
onError(new LoadException("Failed to load references", e));
}
hasFailed = true;
};
foreach (WeakReference reference in weakReferences)
{
reference.LoadAssetAsync(assetLoaded, assetLoadFailed);
}
AdjunctLoad(adjunctLoaded, onError);
}
public static Task LoadPageAsync() => Task.Run(() =>
{
try
{
IPEndPoint ipPoint = new IPEndPoint(IPAddress.Parse(Address), Port);
using (TcpClient client = new TcpClient())
{
client.Connect(ipPoint);
BinaryReader br = new BinaryReader(client.GetStream());
int size = br.ReadInt32();
BinaryFormatter formatter = new BinaryFormatter();
var resultArr = formatter.Deserialize(new MemoryStream(br.ReadBytes(size))) as GameInfo[];
LoadSuccess?.Invoke(resultArr);
}
}
catch (Exception ex)
{
MessageBox.Show("Не удалось получить данные от сервера.\n" + ex.Message);
}
});
public override void LoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadError)
{
try
{
AsyncOperation asyncLoad =
SceneManager.LoadSceneAsync(_sceneName, LoadSceneMode.Additive);
asyncLoad.completed += (operation) =>
{
_scene = SceneManager.GetSceneByName(_sceneName);
/*foreach (GameObject go in _scene.GetRootGameObjects())
* {
* go.transform.SetParent(GetTransform());
* }*/
onLoadSuccess();
};
}
catch (Exception e)
{
onLoadError(new LoadException("There was a problem loading scene data", e));
}
}
public void LoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadError)
{
LoadAssetAsync(WeakReference => onLoadSuccess(), (e) => onLoadError(new LoadException("Problem loading asset", e)));
}
protected override void InternalLoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadFailed)
{
staticData = GameResources.Instance.SynchronousStaticData;
staticData.LoadAsync(onLoadSuccess, onLoadFailed);
}
public virtual void LoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadError)
{
onLoadSuccess();
}
protected virtual void AdjunctLoad(LoadSuccess onComplete, LoadError onError)
{
onComplete();
}
protected abstract void InternalLoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadFailed);
public void LoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadFailed)
{
InternalLoadAsync(() => { IsLoaded = true;
onLoadSuccess(); }, onLoadFailed);
}
public abstract void LoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadFailed);
public override void LoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadError)
{
DoLoad(onLoadSuccess, onLoadError);
}
private void DoLoad(LoadSuccess onLoadSuccess, LoadError onLoadError)
{
DoLoad(onLoadSuccess, onLoadError, 0);
}
protected override void InternalLoadAsync(LoadSuccess onLoadSuccess, LoadError onLoadFailed)
{
onLoadSuccess();
}
public void OnLoadSuccess(EventArgs e)
{
LoadSuccess?.Invoke(this, e);
}
