public override string GetDescription()
{
ResourceMetaData inputResourceData = GetResource(inputResource);
ResourceMetaData outputResourceData = GetResource(outputResource);
string output = "";
if (inputResource != ResourceIdentifiers.NULL)
{
output += $"{inputResource}: {(int)inputResourceData.value}";
output += $"({(int)(inputResourceData.fulfillFactor * 100)}%)";
}
if (inputResource != ResourceIdentifiers.NULL)
{
output += $"\n{outputResource}: {ScaledOutputByResource(inputResource, idealOutput)}";
}
else
{
output += $"\n{outputResource}: {idealOutput}";
}
if (resourceOutputSplit)
{
output += $" (Split amongst {split})";
}
// if(_resourceCapacityEnabled)
// {
// output += $"\nCapacity: {_resourceCapacity}";
// }
return(output);
}
public static Stream CheckIfCompressed(string resourceName, Stream sourceStream, AssemblyDefinition sourceAssembly)
{
bool compressed = false;
var metaResource = sourceAssembly.MainModule.Resources.FirstOrDefault(r => r.Name == (resourceName + "_meta"));
if (metaResource != null && metaResource is EmbeddedResource)
{
var embeddedHash = (EmbeddedResource)metaResource;
using (var metaStream = embeddedHash.GetResourceStream())
{
var meta = ResourceMetaData.FromStream(metaStream);
compressed = meta.compressed;
}
}
if (compressed)
{
MemoryStream finalStream = new MemoryStream();
sourceStream.Decompress(finalStream);
return(finalStream);
}
else
{
return(sourceStream);
}
}
public bool LoadMetaOfResource(string rootPath, string path)
{
var xml = XMLParser.LoadXML(Utils.LoadFile(Path.Combine(rootPath, path)));
if (xml == null)
{
return(false);
}
foreach (SecurityElement item in xml.Children)
{
var meta = new ResourceMetaData();
meta.RelativePath = item.Attribute("path");
meta.MD5 = item.Attribute("md5");
var dependencies = item.Children;
if (dependencies != null && dependencies.Count > 0)
{
meta.Dependencies = new List <string>();
foreach (SecurityElement dependency in dependencies)
{
meta.Dependencies.Add(dependency.Attribute("path"));
}
}
metaOfResource[meta.RelativePath] = meta;
}
return(true);
}
public bool LoadMetaOfResource(string rootPath, string path)
{
var xml = XMLParser.LoadXML(Utils.LoadFile(Path.Combine(rootPath, path)));
if (xml == null)
{
return false;
}
foreach (SecurityElement item in xml.Children)
{
var meta = new ResourceMetaData();
meta.RelativePath = item.Attribute("path");
meta.MD5 = item.Attribute("md5");
var dependencies = item.Children;
if (dependencies != null && dependencies.Count > 0)
{
meta.Dependencies = new List<string>();
foreach (SecurityElement dependency in dependencies)
{
meta.Dependencies.Add(dependency.Attribute("path"));
}
}
metaOfResource[meta.RelativePath] = meta;
}
return true;
}
public override void UpgradeHandoverFrom(Building oldBuilding)
{
if (NeedsResource(ResourceIdentifiers.DURABILITY))
{
ResourceMetaData oldResource = oldBuilding.GetResource(ResourceIdentifiers.DURABILITY);
float previouslyConsumed = oldResource.ideal - oldResource.value;
ReceiveResource(ResourceIdentifiers.DURABILITY, -previouslyConsumed);
}
}
public ResourceMetaData GetResource(ResourceIdentifiers resourceId)
{
ResourceMetaData resource = null;
resources.TryGetValue(resourceId, out resource);
if (resource == null)
{
return(new ResourceMetaData());
}
return(resource);
}
protected float ScaledOutputByResource(ResourceIdentifiers resourceId, float output)
{
ResourceMetaData resource = GetResource(resourceId);
if (resource == null)
{
Debug.Log($"Could not scale resource {resourceId} as it is not needed on this consumer");
return(0);
}
return(output * resource.fulfillFactor);
}
public void ReceiveResource(ResourceIdentifiers resourceId, float amount)
{
if (NeedsResource(resourceId))
{
ResourceMetaData resource = GetResource(resourceId);
resource.value += amount;
}
// else
// {
// Debug.Log($"{id} does not need {resourceId}");
// }
}
private IEnumerator AnalyzeBundleDepends(string versionPath, Dictionary <string, ResourceMetaData> resInfos)
{
WWW www = new WWW(versionPath);
if (bundleVersionBegion != null)
{
bundleVersionBegion(www);
}
yield return(www);
if (www.error != null)
{
UnityEngine.Debug.LogError("version error");
yield break;
}
byte[] bytes;
if (www.assetBundle != null)
{
bytes = (www.assetBundle.LoadAllAssets <TextAsset>()[0]).bytes;
}
else
{
bytes = www.bytes;
}
MemoryStream ms = new MemoryStream(bytes);
BinaryReader br = new BinaryReader(ms);
int i, j, count = br.ReadInt32(), childCount;
for (i = 0; i < count; i++)
{
var meta = new ResourceMetaData();
meta.RelativePath = br.ReadString();
meta.MD5 = br.ReadString();
childCount = br.ReadInt32();
if (childCount > 0)
{
meta.Dependencies = new List <string>();
}
for (j = 0; j < childCount; j++)
{
meta.Dependencies.Add(br.ReadString());
}
resInfos[meta.RelativePath] = meta;
}
bool isFromRomote = www.url.StartsWith("http://");
if (isFromRomote)
{
WriteResourceToLocal(bytes, versionPath.Replace(URL.url + "/Resources/assetbundles/", ""));
}
UnityEngine.Debug.Log("版本配置bundleVersion解析成功");
}
public float ExpendAllResource(ResourceIdentifiers resourceId)
{
ResourceMetaData resource = GetResource(resourceId);
if (resource == null)
{
Debug.Log($"Could not expend resource {resourceId} as it is not needed on this consumer");
return(0);
}
float oldValue = resource.value;
resource.value = 0;
return(oldValue);
}
public async Task <ActionResult <ResourceMetaData> > GetMetaData([FromRouteAttribute] string domain, [FromRouteAttribute] string resource)
{
using (var connection = new SqlConnection(ConnectionString))
{
var dbReader = new DatabaseReader(connection);
var metaData = new ResourceMetaData()
{
Name = resource,
Fields = dbReader.AllTables().First(z => z.Name == resource && z.SchemaOwner == domain).Columns.Select(z => new Field()
{
Name = z.Name,
Type = z.IsForeignKey ? Url.Action("GetMetaData", new { domain = z.SchemaOwner, resource = z.Name }) : z.DataType.NetDataTypeCSharpName
}).ToArray()
};
return(Ok(metaData));
}
}
internal void OnDeserialize()
{
if (string.IsNullOrEmpty(path))
{
_parent = ResourceDatabase.get.root;
}
else
{
_parent = ResourceDatabase.GetFolder(path);
}
if (_parent != null)
{
parent.children.Add(name, this);
}
if (type == Type.Folder)
{
children = new Dictionary <string, ResourceMetaData>();
}
_objectType = System.Type.GetType(_objectTypeName);
}
//--------------------------------------------------------------------/
// Methods
//--------------------------------------------------------------------/
public ResourceMetaData GetChild(string path, Type resourceType = Type.Any)
{
if (type != Type.Folder)
{
return(null);
}
string p = path;
int index = path.IndexOf('/');
if (index > 0)
{
p = path.Substring(0, index);
path = path.Substring(index + 1);
}
else
{
path = "";
}
ResourceMetaData item = null;
if (!children.TryGetValue(p, out item) || item == null)
{
return(null);
}
else if (path.Length > 0)
{
return(item.GetChild(path, resourceType));
}
else if (resourceType != Type.Unknown && item.type != resourceType)
{
return(null);
}
return(item);
}
public void SetErrorMessage(string errorMessage)
{
resourceMeta = new ResourceMetaData(null, null, () => errorMessage);
}
void LoadAudioClipAndPlayDelayed(ResourceMetaData metaData, float vol, float delay)
{
LoadAudioClipAndPlayDelayed(metaData.anyResourcePath, vol, delay);
}
public void SetErrorMessage(Type errorMessageResourceType, string resourceName)
{
resourceMeta = ResourceHelper.BuildResourceAccessor(resourceName, errorMessageResourceType);
}
protected PropertyValidator(string errorMessageResourceName, Type errorMessageResourceType)
{
resourceMeta = ResourceHelper.BuildResourceAccessor(errorMessageResourceName, errorMessageResourceType);
}
public void SetErrorMessage(Expression<Func<string>> resourceSelector)
{
resourceMeta = ResourceHelper.BuildResourceAccessor(resourceSelector);
}
protected PropertyValidator(string errorMessage)
{
resourceMeta = new ResourceMetaData(null, null, () => errorMessage);
}
protected PropertyValidator(Expression<Func<string>> errorMessageResourceSelector)
{
resourceMeta = ResourceHelper.BuildResourceAccessor(errorMessageResourceSelector);
}
public override string GetDescription()
{
ResourceMetaData resource = GetResource(ResourceIdentifiers.ENERGY);
return($"Energy Input: {resource.value} ({Numbers.OneDP(resource.fulfillFactor*100)}%)");
}
void LoadAudioClipAndPlayDelayed( ResourceMetaData metaData , float vol , float delay )
{
LoadAudioClipAndPlayDelayed( metaData.anyResourcePath , vol , delay );
}
public static void EmbedResource(string assemblyToEmbedTo, string resourceName, Stream streamToEmbed, string hash = null, CompressionMethod compression = CompressionMethod.Auto)
{
if (hash == null)
{
hash = streamToEmbed.GetHash();
}
double previousTime = GetTime();
while (GetTime() - previousTime <= 10.0)
{
try
{
using (var resolver = new MainResolver())
{
using (var definition = AssemblyDefinition.ReadAssembly(assemblyToEmbedTo, new ReaderParameters {
ReadWrite = true, AssemblyResolver = resolver
}))
{
var finding = definition.MainModule.Resources.FirstOrDefault(r => r.Name == resourceName);
if (finding != null)
{
var metaResource = definition.MainModule.Resources.FirstOrDefault(r => r.Name == (resourceName + "_meta"));
if (metaResource != null && metaResource is EmbeddedResource)
{
var embeddedHash = (EmbeddedResource)metaResource;
using (var metaStream = embeddedHash.GetResourceStream())
{
var meta = ResourceMetaData.FromStream(metaStream);
if (meta.hash == hash)
{
return;
}
}
}
definition.MainModule.Resources.Remove(finding);
if (metaResource != null)
{
definition.MainModule.Resources.Remove(metaResource);
}
}
if (compression == CompressionMethod.Auto || compression == CompressionMethod.UseCompression)
{
using (var compressedStream = new MemoryStream())
{
//Console.WriteLine("E");
using (var compressionStream = new GZipStream(compressedStream, CompressionMode.Compress))
{
streamToEmbed.CopyToStream(compressionStream);
compressedStream.Position = 0;
Stream smallestStream = compressedStream;
bool actuallyCompressed = true;
if (streamToEmbed.Length < compressedStream.Length && compression == CompressionMethod.Auto)
{
smallestStream = streamToEmbed;
actuallyCompressed = false;
}
var er = new EmbeddedResource(resourceName, ManifestResourceAttributes.Public, smallestStream);
definition.MainModule.Resources.Add(er);
using (var metaStream = new ResourceMetaData(actuallyCompressed, hash).ToStream())
{
var hashResource = new EmbeddedResource(resourceName + "_meta", ManifestResourceAttributes.Public, metaStream);
definition.MainModule.Resources.Add(hashResource);
definition.MainModule.Write();
}
}
}
}
else
{
var er = new EmbeddedResource(resourceName, ManifestResourceAttributes.Public, streamToEmbed);
definition.MainModule.Resources.Add(er);
using (var metaStream = new ResourceMetaData(false, hash).ToStream())
{
var hashResource = new EmbeddedResource(resourceName + "_meta", ManifestResourceAttributes.Public, metaStream);
definition.MainModule.Resources.Add(hashResource);
definition.MainModule.Write();
}
}
}
}
break;
}
catch (Exception e)
{
if (e.Message.Contains("because it is being used by another process"))
{
continue;
}
else
{
throw;
}
}
}
if (GetTime() - previousTime > 10.0)
{
throw new Exception("Embedding Timeout");
}
}
