internal override void OnValidate()
{
base.OnValidate();
portraits = AssetHandler.LoadAllNearbyAssets <Sprite>(this, "Portraits");
spritesheet = AssetHandler.LoadAllNearbyAssets <Sprite>(this, $"{name} Sprite Sheet");
}
public void OnAsset(AssetPacket packet)
{
// If im recieving from the server that i need an asset
if (packet.Asset == null)
{
// if i dont have it
if (!File.Exists(Path.Combine(Application.persistentDataPath, packet.ResquestedImageName)) || DEBUG_ALWAYS_DOWNLOAD)
{
_assetsRequested.Add(packet);
}
else
{
var spriteMap = AssetHandler.LoadNewSprite(Path.Combine(Application.persistentDataPath, packet.ResquestedImageName));
AssetHandler.LoadedAssets.Add(packet.ResquestedImageName, spriteMap);
AssetsRecieved++;
}
}
else
{
Debug.Log("Saving asset " + packet.ResquestedImageName + " SIZE " + packet.Asset.Length);
File.WriteAllBytes(Path.Combine(Application.persistentDataPath, packet.ResquestedImageName), packet.Asset);
var spriteMap = AssetHandler.LoadNewSprite(Path.Combine(Application.persistentDataPath, packet.ResquestedImageName));
AssetHandler.LoadedAssets.Add(packet.ResquestedImageName, spriteMap);
AssetsRecieved++;
if (AssetsRecieved == NumberOfAssetsToRecieve && AssetsRecieved > 0)
{
DoneDownloading();
}
}
}
/// <summary>
/// 卸载资源
/// </summary>
/// <param name="asset"></param>
public void UnloadAssetAsync(UnityEngine.Object asset)
{
MDebug.Assert(asset != null, LOG_TAG, "asset != null");
MDebug.Assert(m_AssetToAssetHandlerMap.ContainsKey(asset), LOG_TAG, "m_AssetToAssetHandlerMap.ContainsKey(asset)");
if (asset == null || !m_AssetToAssetHandlerMap.ContainsKey(asset))
{
return;
}
AssetHandler assetHandler = m_AssetToAssetHandlerMap[asset];
if (assetHandler == null)
{
MDebug.Log(LOG_TAG, $"UnloadAssetAsync({assetHandler.GetAssetKey()})");
AssetAction assetAction = assetHandler.RemoveReference();
switch (assetAction)
{
case AssetAction.Unload:
AddAssetActionRequest(assetHandler.GetAssetIndex(), AssetAction.Unload);
break;
default:
MDebug.Log(LOG_TAG, "unload failed !");
break;
}
}
}
public void GetVersion_Should_Return_Correct_Version()
{
string version;
cache.Expect(c => c.TryGet(It.IsAny <string>(), out version)).Returns(false);
cache.Expect(c => c.Contains(It.IsAny <string>())).Returns(false);
cache.Expect(c => c.Set(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <DateTime>()));
var assetSettings = new AssetSettingsSection
{
CacheDurationInDays = 10,
Compress = true,
Version = "1.5"
};
assetSettings.Assets.Add(new AssetElement {
Name = "js"
});
configurationManager.Expect(c => c.GetSection <AssetSettingsSection>(It.IsAny <string>())).Returns(assetSettings);
string result = AssetHandler.GetVersion("js");
Assert.Equal("1.5", result);
}
public void Awake()
{
if (Instance == null)
{
Instance = this;
}
}
/// <summary>
/// 加载失败
/// </summary>
/// <param name="loader"></param>
public void LoadFailed(AssetHandler loader)
{
this.Loader = loader;
this.IsFinish = true;
OnLoadFinish.Invoke();
OnLoadFinish.RemoveAllListeners();
}
public void SetUp()
{
_game = MockRepository.GenerateMock <IGame>();
_gameHandler = MockRepository.GenerateMock <IGameHandler>();
_gameState = MockRepository.GenerateMock <IHsGameState>();
_gameState.Stub(x => x.GameHandler).Return(_gameHandler);
_assetHandler = new AssetHandler();
}
public void TryAddDependencyAsset(AssetHandler assetHandler)
{
if (m_BundleState != BundleState.Loaded)
{
m_OnBundleLoaded += assetHandler.OnBundleLoaded;
assetHandler.AddNeedLoadBundle();
}
}
/// <summary>
/// 回收
/// </summary>
public void Release()
{
RefCount = 0;
Asset = null;
Loader = null;
Name = string.Empty;
IsFinish = false;
OnLoadFinish.RemoveAllListeners();
}
// 加载 AB
private bool LoadAB <T>(string name, AbMeta ab, AssetHandler <T> handler, ErrorHandler errorhandler, bool loadDependencies = true) where T : Object
{
if (ab == null)
{
var error = string.Format("Can't find AssetBundle \"{0}\"", name);
#if UNITY_EDITOR
RTLog.LogError(LogCat.Asset, error);
#endif
if (errorhandler != null)
{
errorhandler(error);
}
return(false);
}
if (ab.assetBundle != null)
{
if (handler != null)
{
handler(ab.assetBundle as T);
}
return(false);
}
bool load = false;
// 加载依赖包
if (loadDependencies)
{
var dependencies = mManifest.GetAllDependencies(ab.name);
if (dependencies != null)
{
for (int i = 0; i < dependencies.Length; i++)
{
var id = HashAssetID(dependencies[i]);
var dab = GlobalUtil.Binsearch(mAbs, id);
load |= LoadAB <AssetBundle>(dependencies[i], dab, null, null, false);
}
}
}
// 加载 ab
var assethandler = GetHandler(ab.Identify);
if (assethandler == null)
{
assethandler = new ABObtain(ab);
mHandlers.AddLast(assethandler);
mLoaders++;
load = true;
assethandler.DoComplete(FinishAndLoadNextAsset);
}
if (handler != null)
{
assethandler.RegistHandler(handler);
}
if (errorhandler != null)
{
assethandler.RegistErrorHandler(errorhandler);
}
return(load);
}
protected override void LoadAllAssets <T>(string abname, AssetHandler <T> handler, ErrorHandler errorHandler)
{
GetAssetAsync <AssetBundle>(abname, (x) => {
var assets = x.GetAllAssetNames();
foreach (var asset in assets)
{
GetAssetAsync <T>(asset, handler, errorHandler);
}
}, errorHandler);
}
async public void Pressed()
{
var s = new InitVehicle();
s.vehicle_name = "car" + ++counter;
s.vehicle_type = AssetHandler.getInstance().getVehicle();
s.pos = new Vector3(-250, 2, 50);
s.rotation = Quaternion.identity;
VehicleQueue.Enqueue(s);
}
internal override void OnValidate()
{
base.OnValidate();
sprite = AssetHandler.LoadNearbyAssetWithSameName <Sprite>(this);
// TODO: optimize, to avoid sorting all objects each validation
// sort ascending by drop chance, for easier loot spawning
lootTable?.Sort((x, y) => y.dropChance.CompareTo(x.dropChance));
lootTable?.Reverse();
}
// Add vehicle
private static bool AddVehicle(string vehicle_name, string vehicle_type) // Take in init pose and path?
{
Debug.LogError("Attempting to add car: " + vehicle_name + " - " + vehicle_type);
if (vehicle_type == "")
{
vehicle_type = AssetHandler.getInstance().getVehicle();
}
AddCar.GetInstance().SpawnVehicle(vehicle_name, vehicle_type, new Vector3(-250, 2, 50), Quaternion.identity);
return true;
}
void Start()
{
AssetHandler asset = GameManager.Instance.assetHandler;
avatarImage = GetComponent <SpriteRenderer>().sprite;
player = new Player("LocalPlayer", transform, cardPlace);
playerState = new PlayerState(player, avatarPlayer);
avatarPlayer = new Avatar(asset.avatarExpression[0], asset.avatarExpression[1], asset.avatarExpression[2]);
}
public async Task AddMinimalAsset_ReturnsCorrectStageId()
{
var handler = new AssetHandler(BasicNeeds);
var stageId = 100;
var result = await handler.Handle(new Domain.Asset.Commands.AddMinimalAsset
{
StageId = stageId,
}, CancellationToken.None);
Assert.AreEqual(result.StageId, stageId);
}
public void RegisterExtensionHandler(string extension, Action <string> action)
{
if (_extension_handler.ContainsKey(extension))
{
_extension_handler[extension] += new AssetHandler(action);
}
else
{
_extension_handler[extension] = new AssetHandler(action);
}
}
protected override void OnDestroy()
{
if (assetHandler != null)
{
AssetService assetService = Facade.GetInstance().GetServicer <AssetService>(AssetService.NAME);
assetService.UnloadAssetAsync(assetHandler);
assetHandler = null;
}
base.OnDestroy();
}
private static ServerUtils.StringArray GetVehicleTypes()
{
ServerUtils.StringArray array = new ServerUtils.StringArray();
List<string> lst = new List<string>();
foreach(var i in AssetHandler.getInstance().vehicles)
{
lst.Add(i.name);
}
DataManager.ConvertToStringArray(lst, ref array);
return array;
}
private void Update()
{
if (PedestrainQueue.Count > 0)
{
InitPedestrain s = PedestrainQueue.Dequeue();
var obj = Instantiate(AssetHandler.getInstance().getPedestrian(), s.pos, s.rotation);
AirSimServer.pedestrianList.Add(obj);
var component = obj.GetComponent <PedestrianOverhead>();
component.name = s.name;
}
}
private void Update()
{
if (VehicleQueue.Count > 0)
{
InitVehicle s = VehicleQueue.Dequeue();
var type = Array.Find(AssetHandler.getInstance().vehicles, element => element.name == s.vehicle_type);
var obj = Instantiate(type.vehicle, s.pos, s.rotation);
obj.GetComponent <Vehicle>().vehicle_name = s.vehicle_name;
AirSimServer.vehicleList.Add(obj);
}
}
public void ModifyAsset()
{
Parallel.ForEach(_assetfiles, file =>
{
var extension = Path.GetExtension(file);
AssetHandler handler = null;
if (_extension_handler.TryGetValue(extension, out handler))
{
handler.Invoke(file);
}
});
}
/// <summary>
/// 加载成功
/// </summary>
/// <param name="asset"></param>
public void LoadSuccess(AssetHandler loader, Object asset)
{
this.Asset = asset;
this.Loader = loader;
this.IsFinish = true;
#if UNITY_EDITOR
DealEditorMode();
#endif
// loader.AddRefResData(this.Name);
OnLoadFinish.Invoke();
OnLoadFinish.RemoveAllListeners();
}
/// <summary>
/// 异步加载资源
/// </summary>
/// <param name="assetKey"></param>
/// <param name="callback"></param>
public void LoadAssetAsync(AssetKey assetKey, Action <AssetKey, UnityEngine.Object> callback)
{
MDebug.Log(LOG_TAG, $"LoadAssetAsync({assetKey})");
MDebug.Assert(callback != null, LOG_TAG, "callback != null");
int assetIndex = (int)assetKey;
AssetHandler assetHandler = m_AssetHandlers[assetIndex];
if (assetHandler == null)
{
assetHandler = m_AssetHandlerPool.Alloc();
assetHandler.SetAssetKey(assetKey);
m_AssetHandlers[assetIndex] = assetHandler;
}
AssetAction assetAction = assetHandler.AddReference(callback);
switch (assetAction)
{
case AssetAction.RequestLoadBundle:
int bundleIndex = m_AssetInfos[assetIndex].BundleIndex;
int[] dependencyBundleIndexs = m_BundleInfos[bundleIndex].DependencyBundleIndexs;
for (int iBundle = 0; iBundle < dependencyBundleIndexs.Length; iBundle++)
{
int iterDependencyBundleIndex = dependencyBundleIndexs[iBundle];
LoadBundleForLoadAsset(iterDependencyBundleIndex, assetIndex);
}
LoadBundleForLoadAsset(bundleIndex, assetIndex);
//全部依赖Bundle加载完成?
if (assetHandler.GetRemainLoadBundleCount() == 0)
{
AddAssetActionRequest(assetIndex, AssetAction.Load);
}
break;
case AssetAction.Load:
case AssetAction.LoadedCallback:
AddAssetActionRequest(assetIndex, assetAction);
break;
case AssetAction.Null:
// Nothing To Do
break;
default:
MDebug.Assert(false, LOG_TAG, "Asset Not Support AssetAction: " + assetAction);
break;
}
}
void OnValidate()
{
// auto-load all location sprites in each area
foreach (var area in areas)
{
area.locations = new List <Sprite>(AssetHandler.LoadChildAssets <Sprite>(area.areaTexture));
}
// sort ascending enemies spawn list by chance of spawn
enemies = enemies?.OrderBy(x => x.relativeChanceWeight).ToList();
// required to be able to save script changes to SO to an actual asset file (only inspector changes are saved by default)
EditorUtility.SetDirty(this);
}
protected override void LoadContent()
{
///Singleton
_assetHandler = AssetHandler.GetInstance();
///Monogame Loading Content
_spriteBatch = new SpriteBatch(GraphicsDevice);
///Game Assets
_background = new Background(this, "Images/back", 800, 480);
_heroShip = new HeroShip(this, "Images/white_ship", 50, 50, 400, 400, 100, 100, 8); //créer une fabrique
_enemyShip = new EnemyShip(this, "Images/enemy_ship", 50, 50, 400, 50, 50, 0, 5);
}
public void SetupCard(string key, int cardNumb, int type)
{
assetHandler = GameManager.Instance.assetHandler;
setupCard = GameManager.Instance.setupCardHandler;
card = new Card(key, cardNumb, (CardType)type);
cardNumberSprite = GameManager.Instance.assetHandler.GetCardSprite(cardNumb, card.cardType);
spriteRender = GetComponent <SpriteRenderer>();
objCollider = GetComponent <BoxCollider2D>();
startPosition = transform.position;
startScale = transform.localScale;
CloseCard();
}
protected override void LoadAllAssets <T>(string abname, AssetHandler <T> handler, ErrorHandler errorHandler)
{
#if UNITY_EDITOR
abname = abname.ToLower();
var assets = UnityEditor.AssetDatabase.FindAssets("t:" + typeof(T).Name);
foreach (var t in assets)
{
var path = UnityEditor.AssetDatabase.GUIDToAssetPath(t);
var import = UnityEditor.AssetImporter.GetAtPath(path);
if (import.assetBundleName == abname)
{
handler(UnityEditor.AssetDatabase.LoadAssetAtPath <T>(path));
}
}
#endif
}
public void Setup()
{
mockContentRepository = new Mock <IContentRepository>();
mockBlobFactory = new Mock <IBlobFactory>();
mockContextResolver = new Mock <IContextResolver>();
mockLinkResolver = new Mock <ILinkResolver>();
mockContentTypeRepository = new Mock <IContentTypeRepository>();
mockContentMediaResolver = new Mock <ContentMediaResolver>();
assetHandler = new AssetHandler(
mockContentRepository.Object,
mockBlobFactory.Object,
mockContextResolver.Object,
mockLinkResolver.Object,
mockContentTypeRepository.Object,
mockContentMediaResolver.Object);
}
/// <summary>
/// Gathers all the assets from a specific folder into our asset folder
/// </summary>
public void GatherAssetFiles(string fromDir)
{
if (!IO.Directory.Exists(AssetDirectory))
{
IO.Directory.CreateDirectory(AssetDirectory);
}
string blob = AssetHandler.getStartingDirectory(fromDir, "BLOBS");
string asset = AssetHandler.getStartingDirectory(fromDir, "assets");
foreach (string file in directoryServer.AssetManifestList)
{
//Check the inner zone asset folder first
string filePath = AssetHandler.findAssetFile(file, asset);
if (filePath == null)
{
//Get it from the blob folder instead
filePath = AssetHandler.findAssetFile(file, blob);
if (filePath == null)
{
//Still cant find it? Just skip it
continue;
}
}
if (filePath != null)
{
try
{
string path = IO.Path.Combine(AssetDirectory, file);
//Lets copy it over
if (IO.File.Exists(path))
{
IO.File.Delete(path);
}
IO.File.Copy(filePath, path);
}
catch (Exception e)
{
Log.write(TLog.Warning, e.ToString());
}
}
}
}
public MonoGameEngine(SpriteBatch spriteBatch, ContentManager contentManager)
{
this.graphics = new MonoGameGraphics(spriteBatch);
this.assets = new MonoGameAssetHandler(contentManager);
}
