private void Start()
{
string[] directions =
{ "", "E", "ES", "ESW", "EW", "N", "NE", "NES", "NESW", "NEW", "NS", "NSW", "NW", "S", "SW", "W" };
foreach (var wallName in WallNames)
{
foreach (var direction in directions)
{
var address = string.Format("Assets/Sprites/Walls/{0}.png[{0}_{1}]", wallName, direction);
var SpriteHandle = Addressables.LoadAssetAsync <Sprite>(address);
SpriteHandle.Completed += WallSprite_Completed;
}
}
_maxWallTiles = directions.Length * WallNames.Count;
var atlasAddress = "Assets/Sprites/Terrain/Terrain.spriteatlas";
var SpriteAtlasHandle = Addressables.LoadAssetAsync <SpriteAtlas>(atlasAddress);
SpriteAtlasHandle.Completed += TerrainSpriteAtlas_Completed;
atlasAddress = "Assets/Sprites/Objects/Furniture.spriteatlas";
SpriteAtlasHandle = Addressables.LoadAssetAsync <SpriteAtlas>(atlasAddress);
SpriteAtlasHandle.Completed += FurnitureSpriteAtlas_Completed;
foreach (var adress in spriteAtlasAddress)
{
var atlasedSpriteAddress = adress;
Addressables.LoadAssetAsync <SpriteAtlas>(atlasedSpriteAddress).Completed += SpriteAtlasLoaded;
}
}
public void Initialize(ScenarioObject a_ScenarioObject, GameReferences a_GameReferences)
{
m_GameReferences = a_GameReferences;
gameObject.name = a_ScenarioObject.Template.Name;
m_SpriteRenderer.sortingOrder = -32767 + a_ScenarioObject.SortOrder;
uint _ColorIndex = a_ScenarioObject.DwellingOwner;
// Seems neutral objects can represent multiple different values
if (_ColorIndex > 8)
{
_ColorIndex = 8;
}
m_SpriteRenderer.material.SetColor("_PlayerColor", m_PlayerColors.Colors[_ColorIndex]);
var _Operation = Addressables.LoadAssetAsync <MapObjectVisualData>($"MapObjects/{gameObject.name}.asset");
// Synchonously, because underground objects are initially disabled, which break their coroutines
MapObjectVisualData _Data = _Operation.WaitForCompletion();
if (_Operation.Status == UnityEngine.ResourceManagement.AsyncOperations.AsyncOperationStatus.Failed)
{
Debug.Log(gameObject.name);
}
else
{
m_Renderer.SetSprites(_Operation.Result.Sprites);
m_ShadowRenderer.SetSprites(_Operation.Result.ShadowSprites);
}
}
public static T LoadAsset <T>(string path)
{
var handle = Addressables.LoadAssetAsync <T>(path);
//实现同步加载的API
return(handle.WaitForCompletion());
}
public void Add <T>(object key, System.Action <UnityEngine.ResourceManagement.AsyncOperations.AsyncOperationHandle <T> > onComplete = null)
{
var h = Addressables.LoadAssetAsync <T>(key);
h.Completed += onComplete;
handles.Add(h);
}
public void RegisterButtonClick(GameObject go)
{
if (index % 2 == 1)
{
AsyncOperationHandle <SpriteAtlas> handle = Addressables.LoadAssetAsync <SpriteAtlas>("QTE");
// AsyncOperationHandle<Sprite[]> handle = Addressables.LoadAssetAsync<Sprite[]>(atlasName);
handle.Completed += (op) =>
{
if (op.Status == AsyncOperationStatus.Succeeded)
{
atlas = handle.Result;
startButton.image.sprite = atlas.GetSprite("ui_button_001");
// if (!_cachedAtlasDict.ContainsKey(atlasName))
// _cachedAtlasDict.Add(atlasName, handle.Result);
// image.sprite = _cachedAtlasDict[atlasName].GetSprite(imageName);
}
};
}
else
{
Addressables.Release(atlas);
}
index++;
return;
// Debug.Log("Try Register! " + nameInput.text);
// RegisterArgs args = new RegisterArgs();
// args.account = nameInput.text;
// NetworkManager.RegisterReq(args, RegisterAck);
}
private async Task <Material> GetMaterialAsync(eTileType tileType)
{
switch (tileType)
{
case eTileType.Earth:
return(await Addressables.LoadAssetAsync <Material>("Assets/Addressible/Cubes/Materials/Grass.mat").Task);
case eTileType.Stone:
return(await Addressables.LoadAssetAsync <Material>("Assets/Addressible/Cubes/Materials/Grey Stones.mat").Task);
case eTileType.Ocean:
return(await Addressables.LoadAssetAsync <Material>("Assets/Addressible/Cubes/Materials/Water Deep Blue.mat").Task);
case eTileType.Lake:
return(await Addressables.LoadAssetAsync <Material>("Assets/Addressible/Cubes/Materials/Water Light Blue.mat").Task);
case eTileType.Tree:
return(await Addressables.LoadAssetAsync <Material>("Assets/Addressible/Cubes/Materials/Sandy.mat").Task);
case eTileType.Sand:
return(await Addressables.LoadAssetAsync <Material>("Assets/Addressible/Cubes/Materials/Sandy Orange.mat").Task);
}
return(null);
}
public IEnumerator GetSoundAsync(string key, Action <AudioClip> callback)
{
if (!audioDic.ContainsKey(key))
{
switch (sourceType)
{
case SourceType.Resources:
var progress = Resources.LoadAsync <AudioClip>(Path.Combine(soundPath, key).Replace("\\", "/"));
yield return(new WaitUntil(() => progress.isDone));
audioDic.Add(key, progress.asset as AudioClip);
break;
#if ADDRESSABLE_EXISTS
case SourceType.Addressable:
var finalPath = useFormatPath
? string.Format(soundPath, key)
: Path.Combine(soundPath, key).Replace("\\", "/");
var progress3 = Addressables.LoadAssetAsync <AudioClip>(finalPath);
yield return(new WaitUntil(() => progress3.IsDone));
audioDic.Add(key, progress3.Result);
break;
#endif
case SourceType.Custom:
yield return(provider.GetSound(key, result => { audioDic.Add(key, result); }));
break;
}
}
callback(audioDic[key]);
yield break;
}
void ModifyInteractablePrefabWithVanillaAssets()
{
var brokenMtl = Addressables.LoadAssetAsync <Material>("RoR2/Base/Drones/matDroneBrokenGeneric.mat")
.WaitForCompletion();
bulwarkDroneInteractablePrefab.transform.Find("Model Base/BulwarkDrone").GetComponent <MeshRenderer>().material = brokenMtl;
}
protected IEnumerator RunPlayer(string audioName,
float volumeRate,
float delay,
float pitch,
bool isLoop,
Action <AudioSource> callback = null)
{
AudioClip current;
if (!_audioClipDict.ContainsKey(audioName))
{
var handle = Addressables.LoadAssetAsync <AudioClip>(audioName);
yield return(handle);
current = handle.Result;
if (_cacheType == AudioCacheType.Used)
{
_audioClipDict[audioName] = current;
}
}
else
{
current = _audioClipDict[audioName];
}
RunPlayer(current, volumeRate, delay, pitch, isLoop, callback);
}
private IEnumerator Init()
{
AsyncOperationHandle <Sprite> horize = Addressables.LoadAssetAsync <Sprite>("sprite_h");
AsyncOperationHandle <Sprite> vertical = Addressables.LoadAssetAsync <Sprite>("sprite_v");
AsyncOperationHandle <Sprite> lu = Addressables.LoadAssetAsync <Sprite>("sprite_lu");
AsyncOperationHandle <Sprite> ld = Addressables.LoadAssetAsync <Sprite>("sprite_ld");
AsyncOperationHandle <Sprite> ru = Addressables.LoadAssetAsync <Sprite>("sprite_ru");
AsyncOperationHandle <Sprite> rd = Addressables.LoadAssetAsync <Sprite>("sprite_rd");
AsyncOperationHandle <Sprite> tr = Addressables.LoadAssetAsync <Sprite>("sprite_tr");
yield return(horize);
yield return(vertical);
yield return(lu);
yield return(ld);
yield return(ru);
yield return(rd);
yield return(tr);
// 设置图片
sprite_h = horize.Result;
sprite_v = vertical.Result;
sprite_lu = lu.Result;
sprite_ld = ld.Result;
sprite_ru = ru.Result;
sprite_rd = rd.Result;
sprite_tr = tr.Result;
}
public static OperationHandle Load <T>(AssetReference assetRef, System.Action <T> onComplete) where T : UnityEngine.Object
{
AsyncOperationHandle <T> ao = Addressables.LoadAssetAsync <T>(assetRef);
ao.Completed += (x) => { onComplete?.Invoke(x.Result); };
return(new OperationHandle(ao));
}
public void OnButtonClick()
{
button.interactable = false;
m_ClickCount++;
switch (m_ClickCount)
{
case 1:
singleSpriteReference.LoadAssetAsync <Sprite>().Completed += SingleDone;
break;
case 2:
spriteSheetReference.LoadAssetAsync <IList <Sprite> >().Completed += SheetDone;
break;
case 3:
spriteAtlasReference.LoadAssetAsync().Completed += AtlasDone;
break;
case 4:
spriteSubAssetReference.LoadAssetAsync <Sprite>().Completed += SheetSubDone;
break;
case 5:
atlasSubAssetReference.LoadAssetAsync <Sprite>().Completed += AtlasSubDone;
break;
case 6:
Addressables.LoadAssetAsync <Sprite>("sheet[sprite_sheet_4]").Completed += SheetNameSubDone;
break;
case 7:
Addressables.LoadAssetAsync <Sprite>("Atlas[u7]").Completed += AtlasNameSubDone;
break;
}
}
public IEnumerator LoadAllSpriteAtlas(List <string> spriteAltas)
{
Debug.Log("LoadAllSpriteAtlas");
if (spriteAltas == null || spriteAltas.Count <= 0)
{
yield break;
}
foreach (var sa in spriteAltas)
{
var fileName = Path.GetFileNameWithoutExtension(sa);
if (!m_spriteAtlasHandle.ContainsKey(fileName))
{
var handle = Addressables.LoadAssetAsync <SpriteAtlas>(sa);
handle.Completed += OnSpriteAtlasLoaded;
m_spriteAtlasHandle.Add(sa, handle);
m_requestedCount++;
}
}
yield return(new WaitUntil(() =>
{
while (m_requestedCount > 0)
{
return false;
}
return true;
}));
}
internal static void RegisterBuffs()
{
Buffs.TemplArmorBuff = Buffs.AddNewBuff("TemplArmorBuff", Addressables.LoadAssetAsync <BuffDef>("RoR2/Base/RoboBallBoss/bdEngiShield.asset").WaitForCompletion().iconSprite, new Color(0.54f, 0.21f, 0.12f), false, false);
Buffs.TemplarstationaryArmorBuff = Buffs.AddNewBuff("TemplarstationaryArmorBuff", Addressables.LoadAssetAsync <BuffDef>("RoR2/Base/RoboBallBoss/bdEngiShield.asset").WaitForCompletion().iconSprite, new Color(0.74f, 0.41f, 0.32f), false, false);
Buffs.TemplarigniteDebuff = Buffs.AddNewBuff("TemplarScorchedDebuff", Addressables.LoadAssetAsync <BuffDef>("RoR2/Base/ArmorReductionOnHit/bdPulverized.asset").WaitForCompletion().iconSprite, new Color(0.3f, 0.3f, 0.3f), false, true);
Buffs.TemplarOverdriveBuff = Buffs.AddNewBuff("TemplarOverdriveBuff", Addressables.LoadAssetAsync <BuffDef>("RoR2/Base/WarCryOnMultiKill/bdWarCryBuff.asset").WaitForCompletion().iconSprite, new Color(0.84f, 0.51f, 0.42f), false, false);
}
public override void SetupAttributes()
{
base.SetupAttributes();
var captainSD = LegacyResourcesAPI.Load <SkillDef>("SkillDefs/CaptainBody/CaptainSkillUsedUp");
disabledSkillDef = SkillUtil.CloneSkillDef(captainSD);
disabledSkillDef.skillNameToken = "TKSAT_DISABLED_SKILL_NAME";
disabledSkillDef.skillDescriptionToken = "TKSAT_DISABLED_SKILL_DESCRIPTION";
disabledSkillDef.dontAllowPastMaxStocks = false;
disabledSkillDef.beginSkillCooldownOnSkillEnd = true;
ContentAddition.AddSkillDef(disabledSkillDef);
tauntDebuff = ScriptableObject.CreateInstance <BuffDef>();
tauntDebuff.buffColor = Color.white;
tauntDebuff.canStack = false;
tauntDebuff.isDebuff = true;
tauntDebuff.name = "TKSATTaunt";
tauntDebuff.iconSprite = Addressables.LoadAssetAsync <Sprite>("RoR2/Base/Common/MiscIcons/texAttackIcon.png")
.WaitForCompletion();
ContentAddition.AddBuffDef(tauntDebuff);
R2API.Networking.NetworkingAPI.RegisterMessageType <ServerTimedSkillDisable.MsgApply>();
R2API.Networking.NetworkingAPI.RegisterMessageType <ServerTimedSkillDisable.MsgRemove>();
}
public void SpawnObjects()
{
if (_spawnedObjects.Count > 0)
{
DeSpawnObjects();
}
if (!ObjectToSpawn.RuntimeKeyIsValid())
{
return;
}
// load object
_loadOperationHandle = Addressables.LoadAssetAsync <GameObject>(ObjectToSpawn);
_loadOperationHandle.Completed += (operation) =>
{
Vector3 spawnPos;
// then instantiate
for (int i = 0; i < _spawnColumns * _spawnRows; i++)
{
spawnPos = transform.position + i % _spawnColumns * transform.right * _columnOffset + i / _spawnColumns * transform.forward * _rowOffset;
ObjectToSpawn.InstantiateAsync(spawnPos, Quaternion.identity, transform).Completed += (asyncOpHandle) =>
{
_spawnedObjects.Add(asyncOpHandle.Result);
};
}
};
}
IEnumerator LoadAndAssociateResultWithKey(IList <string> keys)
{
if (operationDictionary == null)
{
operationDictionary = new Dictionary <string, AsyncOperationHandle <GameObject> >();
}
AsyncOperationHandle <IList <IResourceLocation> > locations
= Addressables.LoadResourceLocationsAsync(keys,
Addressables.MergeMode.Union, typeof(GameObject));
yield return(locations);
var loadOps = new List <AsyncOperationHandle>(locations.Result.Count);
foreach (IResourceLocation location in locations.Result)
{
AsyncOperationHandle <GameObject> handle =
Addressables.LoadAssetAsync <GameObject>(location);
handle.Completed += obj => operationDictionary.Add(location.PrimaryKey, obj);
loadOps.Add(handle);
}
yield return(Addressables.ResourceManager.CreateGenericGroupOperation(loadOps, true));
Ready.Invoke();
}
protected override void OnCreate()
{
Entities.ForEach(
(ref PlayerInputData playerData) =>
{
playerData.cameraMovement = Vector2.zero;
playerData.playerMovement = Vector2.zero;
playerData.exitPressed = false;
}).Run();
Entities.ForEach((ref AnalogInputData analogData) =>
{
analogData.direction = AnalogType.NONE;
analogData.holdingUp = false;
analogData.holdingDown = false;
analogData.holdingLeft = false;
analogData.holdingRight = false;
}).Run();
Entities.ForEach((ref ToolsInputData toolsData) =>
{
toolsData.grabMode = false;
toolsData.selectMode = false;
}).Run();
// Cargo la configuración de controles
Addressables.LoadAssetAsync <InputSettings>("Assets/Settings/InputSettings.asset").Completed +=
handle => input = handle.Result;
}
public IEnumerator LoadAsset <T>(Action <T> callback)
{
lastLoadTime = DateTime.Now.Ticks;
if (!handle.IsValid())
{
handle = Addressables.LoadAssetAsync <T>(m_assetPath);
yield return(handle);
}
if (!handle.IsDone)
{
yield return(handle);
}
if (handle.Status == AsyncOperationStatus.Succeeded)
{
if (callback != null)
{
loadCount++;
callback((T)handle.Result);
}
}
else
{
YDebuger.LogError("load asset fail " + m_assetPath + " handle state:" + handle.Status);
if (callback != null)
{
callback(default(T));
}
}
}
async UniTask <AsyncOperationHandle <T> > IAssetLoader.Load <T>(object key)
{
await Exist(key);
while (true)
{
var operation = Addressables.LoadAssetAsync <T>(key);
await operation.Task;
if (operation.OperationException != null)
{
var errorResult = await errorRequester.Request(ErrorMessage.Create(ErrorStatus.Fatal, operation.OperationException));
if (errorResult == ErrorResult.Retry)
{
continue;
}
else if (errorResult == ErrorResult.Error)
{
throw operation.OperationException;
}
}
return(operation);
}
}
public IEnumerator GetDialogueAsync(string key, Action <string> callback)
{
switch (sourceType)
{
case SourceType.Resources:
var progress = Resources.LoadAsync <TextAsset>(Path.Combine(dialoguePath, key).Replace("\\", "/"));
yield return(new WaitUntil(() => progress.isDone));
var ta = progress.asset as TextAsset;
callback(ta.text);
break;
#if ADDRESSABLE_EXISTS
case SourceType.Addressable:
var finalPath = useFormatPath
? string.Format(dialoguePath, key)
: Path.Combine(dialoguePath, key).Replace("\\", "/");
var progress3 = Addressables.LoadAssetAsync <TextAsset>(finalPath);
yield return(new WaitUntil(() => progress3.IsDone));
callback(progress3.Result.text);
Addressables.Release(progress3);
break;
#endif
case SourceType.Custom:
yield return(provider.GetDialogue(key, result => { callback(result); }));
break;
}
}
internal AssetReferenceTracker(string _key, AssetReferenceTrackerCallbackDelegate <TObject> _callback)
{
handle = Addressables.LoadAssetAsync <TObject>(_key);
loadingTrackers.Add(handle, new Pair(this, _callback));
handle.Completed += OnCompleted;
}
void Start()
{
// Create operation
opHandle = Addressables.LoadAssetAsync <GameObject>(address);
// Add event handler
opHandle.Completed += Operation_Completed;
}
public async UniTask <TObject> LoadAsync <TObject>(string componentId) where TObject : Object
{
var handler = Addressables.LoadAssetAsync <TObject>(componentId);
var instance = await HandleAddressableCreation(handler);
return(instance);
}
protected override async void OnCreate()
{
var configLoader = Addressables.LoadAssetAsync <SimulationConfig>("SimulationConfig");
await configLoader.Task;
_decayRate = configLoader.Result.PheromoneDecayRate;
}
public void Initialize(ScenarioObject a_ScenarioObject, GameReferences a_GameReferences)
{
m_GameReferences = a_GameReferences;
gameObject.name = a_ScenarioObject.Template.Name;
m_SpriteRenderer.sortingOrder = -32767 + a_ScenarioObject.SortOrder;
if (a_ScenarioObject.Template.IsLowPrioritySortOrder)
{
m_SpriteRenderer.sortingLayerName = "MapLowPriorityObjects";
}
var _Operation = Addressables.LoadAssetAsync <MapObjectVisualData>($"MapObjects/{gameObject.name}.asset");
// Synchonously, because underground objects are initially disabled, which break their coroutines
MapObjectVisualData _Data = _Operation.WaitForCompletion();
if (_Operation.Status == UnityEngine.ResourceManagement.AsyncOperations.AsyncOperationStatus.Failed)
{
Debug.Log(gameObject.name);
}
else
{
Renderer.SetSprites(_Operation.Result.Sprites);
ShadowRenderer.SetSprites(_Operation.Result.ShadowSprites);
}
}
private static void LoadGameObjectAsync <T>(string key, Action <UnityEngine.Object> cb)
{
AsyncOperationHandle handler = new AsyncOperationHandle();
if (mLoadedCbDict.ContainsKey(key) == false)
{
mLoadedCbDict[key] = new List <Action <UnityEngine.Object> >();
}
mLoadedCbDict[key].Insert(0, cb);
handler = Addressables.LoadAssetAsync <T>(key);
handler.Completed += (AsyncOperationHandle loadedHandler) =>
{
if (loadedHandler.Status == AsyncOperationStatus.Succeeded)
{
mAssetCacheDict[key] = loadedHandler;
if (mLoadedCbDict.ContainsKey(key) == false)
{
Debug.LogError("资源加载完成，但回调已经清空" + key);
Addressables.Release(handler);
return;
}
int count = mLoadedCbDict[key].Count;
for (int i = count - 1; i >= 0; i--)
{
mLoadedCbDict[key][i](loadedHandler.Result as UnityEngine.Object);
}
mLoadedCbDict[key].Clear();
}
};
}
protected override void OnCreate()
{
enemyArchetype = EntityManager.CreateArchetype(
typeof(LocalToWorld),
typeof(Translation),
typeof(Rotation),
typeof(Velocity),
typeof(Faction),
typeof(Health),
typeof(Cooldown),
typeof(ColliderComponent),
typeof(Speed),
typeof(RenderBounds),
typeof(RenderMesh),
typeof(Enemy));
Addressables.LoadAssetAsync <EnemySettings>("EnemyPrefabs").Completed += OnEnemyPrefabListLoadComplete;
Addressables.LoadAssetAsync <EnemyWaveSettings>("EnemyWaveSettings").Completed += OnEnemyWaveSettingsLoadComplete;
var query = new EntityQueryDesc
{
All = new ComponentType[] { typeof(EnemySettingsComponent) }
};
enemySettingsEntityQuery = GetEntityQuery(query);
var enemyQuery = new EntityQueryDesc
{
All = new ComponentType[] { typeof(Enemy) }
};
enemyEntityQuery = GetEntityQuery(enemyQuery);
}
/// <summary>
/// Load the specified addressable resource
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="name"></param>
/// <param name="resourceLoadedCallback"></param>
public async Task <T> LoadResourceAsync <T>(string name)
{
//If we already loaded the resource
if (resources.ContainsKey(name + typeof(T).ToString()))
{
//Use it directly
return((T)resources[name]);
}
else
{
//Load it
if (typeof(T) == typeof(SceneInstance))
{
//If it is scene, load it to switch current scene
handles.Add(Addressables.LoadSceneAsync(name));
T result = default(T);
return(result);
}
else
{
var handle = Addressables.LoadAssetAsync <T>(name);
handles.Add(handle);
await handle;
var resource = handle.Result;
resources[name + typeof(T).ToString()] = resource;
return(resource);
}
}
}
// Start is called before the first frame update
async void Start()
{
var dll = await Addressables.LoadAssetAsync <TextAsset>(Consts.Paths.HOT_DLL_NAME).Task;
hotMgr.Init(dll);
Init(transform);
}
