//public GameObjectTreeNode TreeNode;
public AssetItem(Object asset)
{
Asset = asset;
SourceFile = asset.assetsFile;
FullSize = asset.byteSize;
Type = asset.type;
TypeString = Type.ToString();
}
public AssetItem(ObjectReader reader)
{
sourceFile = reader.assetsFile;
this.reader = reader;
FullSize = reader.byteSize;
Type = reader.type;
TypeString = Type.ToString();
}
static void WriteFileInfo(SerializedFile container, StreamWriter sw)
{
sw.WriteLine($" File: {container.Name}");
sw.WriteLine($" File.Collection: {container.Collection}");
sw.WriteLine($" File.Platform: {container.Platform}");
sw.WriteLine($" File.Version: {container.Version}");
foreach (var dep in container.Dependencies)
{
sw.WriteLine($" File.Dependency: {dep}");
sw.WriteLine($" Dependency.AssetPath: {dep.AssetPath}");
sw.WriteLine($" Dependency.FilePath: {dep.FilePath}");
sw.WriteLine($" Dependency.FilePathOrigin: {dep.FilePathOrigin}");
}
if (container.Metadata.Hierarchy != null)
{
var SerializeTypeTrees = Util.GetMember <bool>(container.Metadata.Hierarchy, "SerializeTypeTrees");
var Types = Util.GetMember <IReadOnlyList <object> >(container.Metadata.Hierarchy, "Types");
var Name = Util.GetMember <string>(container.Metadata.Hierarchy, "Name");
sw.WriteLine($" File.Metadata.Hierarchy:");
sw.WriteLine($" Hierarchy.Name: {Name}");
sw.WriteLine($" Hierarchy.SerializeTypeTrees: {SerializeTypeTrees}");
sw.WriteLine($" Hierarchy.Types: {Types.Count}");
if (Types.Count > 0)
{
sw.WriteLine($" ClassID, IsStrippedType, ScriptID, ScriptHash, TypeHash, NodeCount");
}
foreach (var type in Types)
{
var ClassID = Util.GetMember <ClassIDType>(type, "ClassID");
var IsStrippedType = Util.GetMember <bool>(type, "IsStrippedType");
var ScriptID = Util.GetMember <short>(type, "ScriptID");
var Tree = Util.GetMember <object>(type, "Tree");
var ScriptHash = Util.GetMember <Hash128>(type, "ScriptHash");
var TypeHash = Util.GetMember <Hash128>(type, "TypeHash");
var nodeCount = Tree == null ? "Null" : Util.GetMember <IReadOnlyList <object> >(Tree, "Nodes").Count.ToString();
sw.WriteLine($" {ClassID}, {IsStrippedType}, {ScriptID}, {HashToString(ScriptHash)}, {HashToString(TypeHash)}, {nodeCount}");
}
}
else
{
sw.WriteLine($" File.Metadata.Hierarchy: Null");
}
sw.WriteLine($" File.Metadata.Entries: {container.Metadata.Entries.Count}");
var factory = new AssetFactory();
foreach (var entry in container.Metadata.Entries)
{
var info = entry.Value;
AssetInfo assetInfo = new AssetInfo(container, info.PathID, info.ClassID);
Object asset = factory.CreateAsset(assetInfo);
if (asset == null)
{
sw.WriteLine($" Unimplemented Asset: {info.ClassID}, {info.ScriptID}, {info.TypeID}, {info.PathID}, {info.IsStripped}");
}
}
}
public static void Prepare()
{
if (file != null || String.IsNullOrEmpty(Program.m_gamedir))
{
return;
}
var st = new System.Diagnostics.Stopwatch();
st.Start();
assetsManager.LoadFiles(new [] { Path.Combine(Program.m_gamedir, "Overload_Data", "resources.assets") });
st.Stop();
System.Diagnostics.Debug.WriteLine("BuildAssetModels.Prepare Reading assets: " + st.Elapsed);
var EntityIds = new Dictionary <string, Tuple <int, int> >(StringComparer.OrdinalIgnoreCase);
foreach (var type in new [] { EntityType.DOOR, EntityType.ENEMY, EntityType.ITEM, EntityType.PROP, EntityType.SPECIAL })
{
string pre = "entity_" + type.ToString() + "_";
foreach (var sub_type_field in GetEntityTypeEnumType(type).GetFields())
{
if (sub_type_field.IsLiteral)
{
EntityIds.Add(pre + sub_type_field.Name, new Tuple <int, int>((int)type, (int)sub_type_field.GetValue(null)));
}
}
}
file = assetsManager.assetsFileList[0];
foreach (var obj in file.Objects)
{
if (obj.type == ClassIDType.GameObject)
{
var go = (GameObject)obj;
if (go.m_Name.StartsWith("entity_"))
{
string name = go.m_Name, new_name;
if (EntityRename.TryGetValue(name, out new_name))
{
if (new_name == null)
{
continue;
}
name = new_name;
}
Tuple <int, int> entityId;
if (EntityIds.TryGetValue(name, out entityId))
{
EntityGameObjects.Add(entityId, go);
}
}
}
}
System.Diagnostics.Debug.WriteLine($"Finished loading {assetsManager.assetsFileList.Count} files with {file.Objects.Count} exportable assets.");
}
public static SerializedFileModel MapTo(SerializedFile file)
{
return(new SerializedFileModel
{
Id = file.Id,
Name = file.Name,
FileContent = file.FileContent,
Extension = file.Extension
});
}
public AssetItem(Object asset)
{
Asset = asset;
SourceFile = asset.assetsFile;
Type = asset.type;
TypeString = Type.ToString();
m_PathID = asset.m_PathID;
FullSize = asset.byteSize;
m_IsReadable = asset.m_IsReadable;
}
private void AddItem(IList <FileEntry> entries, SerializedFile file)
{
int index = 0;
FileEntry[] children = new FileEntry[file.Metadata.Object.Length];
foreach (ObjectInfo entry in file.Metadata.Object)
{
children[index++] = new FileEntry($"{entry.FileID}. {entry.ClassID}");
}
entries.Add(new FileEntry(file.Name, children));
}
public IActionResult DbDownload(IEnumerable <int> ids, IEnumerable <FileExtEnum> ext)
{
List <SerializedFileDto> dtoCheckedFileList = _context.SerializedFile.Where(x => ids.Contains(x.Id)).ToList();
List <SerializedFile> checkedFileList = new List <SerializedFile>();
foreach (SerializedFileDto serializedFileDto in dtoCheckedFileList)
{
SerializedFile serializedFile = SerializedFileDto.MapTo(serializedFileDto);
serializedFile.Extension = "." + ext.ToString();
checkedFileList.Add(serializedFile);
}
if (checkedFileList.Count == 0)
{
return(RedirectToAction("CheckDelete"));
}
if (checkedFileList.Count == 1)
{
//int checkedItemIndex = fileGridView.SelectedCells[0].RowIndex;
//DataGridViewRow selectedRow = fileGridView.Rows[checkedItemIndex];
//var checkedItem = Convert.ToString(selectedRow.Cells["FileName"].Value);
//var checkedExt = "." + Convert.ToString(selectedRow.Cells["DownloadFormat"].Value);
//var db = new FiledbEntities();
//var checkedItemContent = db.SerializedFiles.FirstOrDefault(x =>
// x.Name == checkedItem)?.FileContent;
//SerializedFile file = _fileSerialization.CreateFile(SerializedFile., checkedExt, checkedItemContent);
switch (ext)
{
//case FileExtEnum.xml:
// _fileSerialization.XmlSerializeToFile(SerializedFileDto.MapTo(checkedFileList[0]));
//case ".json":
// _fileSerialization.JsonSerializeToFile(SerializedFileDto.MapTo(file));
// MessageBox.Show(@"Json serialized file downloaded");
// break;
//case ".bin":
// _fileSerialization.BinarySerializeToFile(SerializedFileDto.MapTo(file));
// MessageBox.Show(@"Bin serialized file downloaded");
// break;
//default:
// MessageBox.Show(@"Please select a format to download");
// break;
}
return(RedirectToAction("CheckDelete"));
}
return(RedirectToAction("CheckDelete"));
}
public void Unload(string filepath)
{
for (int i = 0; i > m_files.Count; i++)
{
SerializedFile file = m_files[i];
if (file.FilePath == filepath)
{
m_files.RemoveAt(i);
i--;
}
}
}
internal override bool Export(string targetFile, object targetObject)
{
try
{
SerializedFile.SaveXml(targetFile, targetObject);
return(true);
}
catch (Exception ee)
{
ee.ThrowMyCustomizedException();
return(false);
}
}
public void LoadSerializedFile(string filePath)
{
SerializedFile.Parameters pars = new SerializedFile.Parameters()
{
FileCollection = this,
AssemblyManager = AssemblyManager,
FilePath = filePath,
Name = Path.GetFileName(filePath),
DependencyCallback = OnRequestDependency,
};
SerializedFile file = SerializedFile.Load(pars);
AddSerializedFile(file);
}
public SerializedFile ReadSerializedFile(IAssetCollection collection, string filePath)
{
SerializedFile file = new SerializedFile(collection, filePath, Name);
m_stream.Position = m_offset;
file.Read(m_stream);
long read = m_stream.Position - m_offset;
if (read != m_size)
{
//throw new System.Exception($"Read {read} but expected {m_length}");
}
return(file);
}
internal void ReadSerializedFile(Stream stream, string filePath, string fileName, Action <string> dependencyCallback)
{
SerializedFile.Parameters pars = new SerializedFile.Parameters()
{
FileCollection = this,
AssemblyManager = AssemblyManager,
FilePath = filePath,
Name = fileName,
DependencyCallback = dependencyCallback,
};
SerializedFile file = SerializedFile.Read(stream, pars);
AddSerializedFile(file);
}
public SerializedFile ReadSerializedFile(IFileCollection collection, Action <string> requestDependencyCallback)
{
SerializedFile file = new SerializedFile(collection, m_filePath, Name);
m_stream.Position = m_offset;
file.Read(m_stream, requestDependencyCallback);
long read = m_stream.Position - m_offset;
if (read != m_size)
{
//throw new System.Exception($"Read {read} but expected {m_length}");
}
return(file);
}
internal static void DumpTypeInfo(SerializedFile serializedFile, StreamWriter sw)
{
foreach (var asset in serializedFile.FetchAssets().Where(asset => asset is MonoScript))
{
var monoScript = asset as MonoScript;
sw.WriteLine($"\t[{monoScript.AssemblyName}]{monoScript.Namespace}.{monoScript.ClassName} - {HashToString(monoScript.PropertiesHash)}");
}
sw.WriteLine($"SerializedFile");
sw.WriteLine($"Name {serializedFile.Name}");
sw.WriteLine($"NameOrigin {serializedFile.NameOrigin}");
sw.WriteLine($"Platform {serializedFile.Platform}");
sw.WriteLine($"Version {serializedFile.Version}");
sw.WriteLine($"Preloads:");
foreach (var ptr in serializedFile.Metadata.Preloads)
{
sw.WriteLine($"\t{ptr}");
}
var hierarchy = serializedFile.Metadata.Hierarchy;
sw.WriteLine($"TypeTree Version {hierarchy.Version}");
sw.WriteLine($"TypeTree Platform {hierarchy.Platform}");
var SerializeTypeTrees = Util.GetMember <bool>(hierarchy, "SerializeTypeTrees");
sw.WriteLine($"TypeTree SerializeTypeTrees {SerializeTypeTrees}");
var Unknown = Util.GetMember <int>(hierarchy, "Unknown");
sw.WriteLine($"TypeTree Unknown {Unknown}");
sw.WriteLine($"");
var types = Util.GetMember <IReadOnlyList <object> >(hierarchy, "Types");
foreach (var type in types)
{
var ClassID = Util.GetMember <ClassIDType> (type, "ClassID");
var ScriptID = Util.GetMember <short>(type, "ScriptID");
var IsStrippedType = Util.GetMember <bool>(type, "IsStrippedType");
var Tree = Util.GetMember <object>(type, "Tree");
var ScriptHash = Util.GetMember <Hash128>(type, "ScriptHash");
var TypeHash = Util.GetMember <Hash128>(type, "TypeHash");
var monoScript = serializedFile.FetchAssets().FirstOrDefault(asset => asset is MonoScript ms && CompareHash(ms.PropertiesHash, TypeHash)) as MonoScript;
string scriptType = monoScript == null ? "\tNo Script" : $"\tMonoScript is [{monoScript.AssemblyName}]{monoScript.Namespace}.{monoScript.ClassName}";
sw.WriteLine(scriptType);
sw.WriteLine($"\tType: ClassID {ClassID}, ScriptID {ScriptID}, IsStrippedType {IsStrippedType}, ScriptHash {HashToString(ScriptHash)}, TypeHash {HashToString(TypeHash)}");
var Dump = Util.GetMember <string>(Tree, "Dump");
sw.WriteLine($"\t{Dump}");
sw.WriteLine($"");
}
sw.WriteLine($"");
}
internal void ReadSerializedFile(Stream stream, string filePath, string fileName, TransferInstructionFlags flags)
{
SerializedFile.Parameters pars = new SerializedFile.Parameters()
{
FileCollection = this,
AssemblyManager = AssemblyManager,
FilePath = filePath,
Name = fileName,
DependencyCallback = OnRequestDependency,
Flags = flags,
};
SerializedFile file = SerializedFile.Load(pars);
AddSerializedFile(file);
}
private static byte[] GetDataOfs(StreamingInfo m_StreamData, SerializedFile assetsFile, int ofs, int len)
{
ResourceReader resourceReader;
if (!string.IsNullOrEmpty(m_StreamData?.path))
{
resourceReader = new ResourceReader(m_StreamData.path, assetsFile, m_StreamData.offset + (long)ofs, len);
return(resourceReader.GetData());
}
else
{
//resourceReader = new ResourceReader(reader, reader.BaseStream.Position, image_data_size);
throw new Exception("embedded image data not supported");
}
}
public IActionResult CheckDelete(IEnumerable <int> ids)
{
List <SerializedFileDto> dtoCheckedFileList = _context.SerializedFile.Where(x => ids.Contains(x.Id)).ToList();
List <SerializedFile> checkedFileList = new List <SerializedFile>();
foreach (SerializedFileDto serializedFileDto in dtoCheckedFileList)
{
SerializedFile serializedFile = SerializedFileDto.MapTo(serializedFileDto);
checkedFileList.Add(serializedFile);
}
_fileDbService.FileDelete(checkedFileList);
return(View());
}
public SerializedFile BinarySerializeToFile(SerializedFileDto file)
{
var path = $@"D:\\App\\TextFileDemoApp\\Serialized dB downloaded\\{file.Name}{file.Extension}";
using (var fileStream = new FileStream(path, FileMode.Create))
{
var serializer = new BinaryFormatter();
serializer.Serialize(fileStream, file);
}
var serializedItemContent = ReadFile(file.Name + file.Extension, path);
SerializedFile serializedFile =
CreateFile(file.Name, file.Extension, serializedItemContent);
return(serializedFile);
}
public SerializedFile XmlSerializeToFile(SerializedFileDto file)
{
var serializer = new System.Xml.Serialization.XmlSerializer(typeof(SerializedFileDto));
var path = $@"D:\\App\\TextFileDemoApp\\Serialized dB downloaded\\{file.Name}{file.Extension}";
var localFile = File.Create(path);
serializer.Serialize(localFile, file);
localFile.Close();
var serializedItemContent = ReadFile(file.Name + file.Extension, path);
SerializedFile serializedFile =
CreateFile(file.Name, file.Extension, serializedItemContent);
return(serializedFile);
}
private void ProcessSerializedFileData(BundleFileData fileData, string filePath)
{
foreach (BundleMetadata metadata in fileData.Metadatas)
{
foreach (BundleFileEntry entry in metadata.AssetsEntries)
{
SerializedFile file = entry.ReadSerializedFile(this, filePath);
AddSerializedFile(file);
}
foreach (BundleFileEntry entry in metadata.ResourceEntries)
{
ResourcesFile resesFile = entry.ReadResourcesFile(filePath);
m_resources.Add(resesFile);
}
}
}
private void SetVersion(SerializedFile file)
{
if (file.Version.IsSet)
{
return;
}
foreach (Object asset in file.Assets)
{
if (asset.ClassID == ClassIDType.BuildSettings)
{
BuildSettings settings = (BuildSettings)asset;
file.Version.Parse(settings.BSVersion);
break;
}
}
}
public Object(ObjectReader reader)
{
this.reader = reader;
reader.Reset();
assetsFile = reader.assetsFile;
type = reader.type;
m_PathID = reader.m_PathID;
version = reader.version;
buildType = reader.buildType;
platform = reader.platform;
serializedType = reader.serializedType;
byteSize = reader.byteSize;
if (platform == BuildTarget.NoTarget)
{
var m_ObjectHideFlags = reader.ReadUInt32();
}
}
public ResourcesFile FindResourcesFile(ISerializedFile ifile, string fileName)
{
SerializedFile file = (SerializedFile)ifile;
const string archivePrefix = "archive:/";
if (fileName.StartsWith(archivePrefix))
{
fileName = Path.GetFileName(fileName);
}
// check assets bundles / web files
string filePath = file.FilePath;
foreach (ResourcesFile res in m_resources)
{
if (res.FilePath == filePath && res.Name == fileName)
{
return(res);
}
}
// check manualy loaded resource files
string dirPath = Path.GetDirectoryName(filePath) ?? string.Empty;
string resPath = Path.Combine(dirPath, fileName);
foreach (ResourcesFile res in m_resources)
{
if (res.FilePath == resPath && res.Name == fileName)
{
return(res);
}
}
// lazy loading
if (FileMultiStream.Exists(resPath))
{
Stream stream = FileMultiStream.OpenRead(resPath);
ResourcesFile resesFile = new ResourcesFile(resPath, fileName, stream);
m_resources.Add(resesFile);
return(resesFile);
}
return(null);
}
private void AddSerializedFile(SerializedFile file)
{
if (m_files.Any(t => t.Name == file.Name))
{
throw new ArgumentException($"Assets file with name '{file.Name}' already presents in collection", nameof(file));
}
if (!RTTIClassHierarchyDescriptor.IsReadSignature(file.Header.Generation))
{
SetVersion(file);
}
if (m_files.Any(t => !t.Platform.IsCompatible(file.Platform)))
{
throw new ArgumentException($"Assets file '{file.Name}' has incompatible with other assets files platform {file.Platform} ", nameof(file));
}
m_files.Add(file);
}
public SerializedFile JsonSerializeToFile(SerializedFileDto file)
{
var serializer = new JsonSerializer();
var path = $@"D:\\App\\TextFileDemoApp\\Serialized dB downloaded\\{file.Name}{file.Extension}";
using (var fileStream = new StreamWriter(path))
{
using (var writer = new JsonTextWriter(fileStream))
{
serializer.Serialize(writer, file);
}
}
var serializedItemContent = ReadFile(file.Name + file.Extension, path);
SerializedFile serializedFile =
CreateFile(file.Name, file.Extension, serializedItemContent);
return(serializedFile);
}
static void DumpFileInfo(SerializedFile container, string exportPath)
{
Console.WriteLine($"Dumping container {container.Name }");
Directory.CreateDirectory(Path.GetDirectoryName(exportPath));
using (var sw = new StreamWriter($"{exportPath}.txt"))
{
WriteFileInfo(container, sw);
sw.WriteLine("");
DumpObjectInfo(container.FetchAssets(), sw);
if (container.Name == "globalgamemanagers")
{
BuildSettings buildSettings = (BuildSettings)container.FetchAssets().FirstOrDefault(asset => asset is BuildSettings);
if (buildSettings != null)
{
sw.WriteLine("");
DumpBuildSettings(buildSettings, sw);
}
}
}
}
public void Unload(string filepath)
{
for (int i = 0; i > m_files.Count; i++)
{
SerializedFile file = m_files[i];
if (file.FilePath == filepath)
{
m_files.RemoveAt(i);
i--;
}
}
for (int i = 0; i > m_resources.Count; i++)
{
ResourcesFile file = m_resources[i];
if (file.FilePath.StartsWith(filepath, StringComparison.Ordinal))
{
file.Dispose();
m_resources.RemoveAt(i);
i--;
}
}
}
private void OnRequestDependency(string dependency)
{
if (IsSerializedFileLoaded(dependency))
{
return;
}
foreach (BundleMetadata metadata in Metadatas)
{
foreach (BundleFileEntry entry in metadata.AssetsEntries)
{
if (entry.Name == dependency)
{
SerializedFile file = entry.ReadSerializedFile(m_fileCollection, OnRequestDependency);
m_files.Add(file);
return;
}
}
}
m_requestDependencyCallback?.Invoke(dependency);
}
public List <SerializedFile> GetCheckedItemsList()
{
List <SerializedFile> checkedItemsList = new List <SerializedFile>();
foreach (DataGridViewRow row in fileGridView.Rows)
{
bool isChecked = (bool)row.Cells[1].EditedFormattedValue;
string checkedItem = (string)row.Cells[0].EditedFormattedValue;
string checkedExt = (string)row.Cells[2].EditedFormattedValue;
if (isChecked)
{
var db = new FiledbEntities();
var checkedItemContent = (db.SerializedFiles.FirstOrDefault(x =>
x.Name == checkedItem))?.FileContent;
SerializedFile file =
_fileSerialization.CreateFile(checkedItem, "." + checkedExt, checkedItemContent);
checkedItemsList.Add(file);
}
}
return(checkedItemsList);
}
