public VirtualMemoryStream(string path, int virtualAddress)
: base(File.ReadAllBytes(path))
{
map = new VirtualMappedAddress()
{
Address = virtualAddress, Length = (int)this.Length, Magic = virtualAddress
};
}
public void Validate(TagDatum datum, Stream dataStream)
{
error = false;
_pointersList = new List <Tuple <BlamPointer, ElementArray> >();
_writeMessage = Console.WriteLine;
var offset = 0;
var definition =
new MoonfishTagGroup(Guerilla.h2Tags.First(x => x.Class == datum.Class));
var definitionPool = Guerilla.h2Tags.Select(x => new MoonfishTagGroup(x));
var elementArray = CompileElementArray(definition, definitionPool, offset);
elementArray.count = 1;
var binaryReader = new BinaryReader(dataStream);
var virtualTagMemory = new VirtualMappedAddress
{
Address = datum.VirtualAddress,
Length = datum.Length
};
_isValidDelegate = virtualTagMemory.Contains;
_isPointerOwnedByTagDelegate = virtualTagMemory.Contains;
offset = (int)dataStream.Seek(datum.VirtualAddress, SeekOrigin.Begin);
elementArray.virtualAddress = datum.VirtualAddress;
ValidateTagBlock(elementArray, elementArray.ToFixedArrayPointer(), binaryReader, ref offset);
if (error)
{
OnWriteMessage(string.Format("Tag ({0}.{1})", datum.Path, datum.Class.ToTokenString()));
}
}
public string Validate(tag_group validateTag, IEnumerable <tag_group> tagPool)
{
PointersList = new List <Tuple <BlamPointer, ElementArray> >();
StreamWriter stringWriter = File.CreateText(string.Format(@"C:\Users\stem\Documents\h2pc to h2xbox\analysis\{0}.txt", validateTag.Class.ToSafeString()));
WriteMessage = new Log(stringWriter.WriteLine);
int offset = 0;
ElementArray elementArray = null;
if (validateTag.ParentClass != TagClass.Null)
{
var parentClass = tagPool.Where(x => x.Class == validateTag.ParentClass).Single();
if (parentClass.ParentClass != TagClass.Null)
{
var baseClass = tagPool.Where(x => x.Class == parentClass.ParentClass).Single();
elementArray = ProcessTagBlockDefinition(baseClass.Definition, ref offset, true);
elementArray.Append(ProcessTagBlockDefinition(parentClass.Definition, ref offset, true));
elementArray.Append(ProcessTagBlockDefinition(validateTag.Definition, ref offset, true));
}
else
{
elementArray = ProcessTagBlockDefinition(parentClass.Definition, ref offset, true);
elementArray.Append(ProcessTagBlockDefinition(validateTag.Definition, ref offset, true));
}
}
else
{
elementArray = ProcessTagBlockDefinition(validateTag.Definition, ref offset, true);
}
elementArray.Count = 1;
var mapFiles = Directory.GetFiles(@"C:\Users\stem\Documents\modding\singleplayer", "*.map", SearchOption.TopDirectoryOnly)
.Concat(Directory.GetFiles(@"C:\Users\stem\Documents\modding\multiplayer", "*.map", SearchOption.TopDirectoryOnly))
.Concat(Directory.GetFiles(@"C:\Users\stem\Documents\modding\resource", "*.map", SearchOption.TopDirectoryOnly));
foreach (var file in mapFiles)
{
using (var map = new MapStream(file))
{
var binaryReader = new BinaryReader(map);
OnWriteMessage(string.Format("Begin ({0})", map.MapName));
foreach (var tag in map.Tags)
{
if (!(tag.Type == validateTag.Class))
{
continue;
}
else
{
VirtualMappedAddress metaTableMemory = new VirtualMappedAddress()
{
Address = map.Tags[0].VirtualAddress, Length = map.TagCacheLength
};
isValidDelegate = new Func <BlamPointer, bool>(metaTableMemory.Contains);
VirtualMappedAddress virtualTagMemory = new VirtualMappedAddress()
{
Address = tag.VirtualAddress, Length = tag.Length
};
IsPointerOwnedByTagDelegate = new Func <BlamPointer, bool>(virtualTagMemory.Contains);
OnWriteMessage(string.Format("Tag ({0})", tag.Path));
map[tag.Identifier].Seek();
offset = (int)map.Position;
elementArray.VirtualAddress = map[tag.Identifier].Meta.VirtualAddress;
PointersList = new List <Tuple <BlamPointer, ElementArray> >();
ValidateTagBlock(elementArray, elementArray.ToFixedArrayPointer(), binaryReader, ref offset);
AnalyzePointers(PointersList);
stringWriter.Flush();
}
}
Console.WriteLine(string.Format("Parsed ({0})", map.MapName));
//OnWriteMessage(string.Format("End ({0})", map.MapName));
}
}
stringWriter.Close();
return("");
}
public string Validate(tag_group validateTag, IEnumerable<tag_group> tagPool)
{
PointersList = new List<Tuple<BlamPointer, ElementArray>>();
StreamWriter stringWriter = File.CreateText(string.Format(@"C:\Users\stem\Documents\h2pc to h2xbox\analysis\{0}.txt", validateTag.Class.ToSafeString()));
WriteMessage = new Log(stringWriter.WriteLine);
int offset = 0;
ElementArray elementArray = null;
if (validateTag.ParentClass != TagClass.Null)
{
var parentClass = tagPool.Where(x => x.Class == validateTag.ParentClass).Single();
if (parentClass.ParentClass != TagClass.Null)
{
var baseClass = tagPool.Where(x => x.Class == parentClass.ParentClass).Single();
elementArray = ProcessTagBlockDefinition(baseClass.Definition, ref offset, true);
elementArray.Append(ProcessTagBlockDefinition(parentClass.Definition, ref offset, true));
elementArray.Append(ProcessTagBlockDefinition(validateTag.Definition, ref offset, true));
}
else
{
elementArray = ProcessTagBlockDefinition(parentClass.Definition, ref offset, true);
elementArray.Append(ProcessTagBlockDefinition(validateTag.Definition, ref offset, true));
}
}
else
{
elementArray = ProcessTagBlockDefinition(validateTag.Definition, ref offset, true);
}
elementArray.Count = 1;
var mapFiles = Directory.GetFiles(@"C:\Users\stem\Documents\modding\singleplayer", "*.map", SearchOption.TopDirectoryOnly)
.Concat(Directory.GetFiles(@"C:\Users\stem\Documents\modding\multiplayer", "*.map", SearchOption.TopDirectoryOnly))
.Concat(Directory.GetFiles(@"C:\Users\stem\Documents\modding\resource", "*.map", SearchOption.TopDirectoryOnly));
foreach (var file in mapFiles)
{
using (var map = new MapStream(file))
{
var binaryReader = new BinaryReader(map);
OnWriteMessage(string.Format("Begin ({0})", map.MapName));
foreach (var tag in map.Tags)
{
if (!(tag.Type == validateTag.Class)) continue;
else
{
VirtualMappedAddress metaTableMemory = new VirtualMappedAddress() { Address = map.Tags[0].VirtualAddress, Length = map.TagCacheLength };
isValidDelegate = new Func<BlamPointer, bool>(metaTableMemory.Contains);
VirtualMappedAddress virtualTagMemory = new VirtualMappedAddress() { Address = tag.VirtualAddress, Length = tag.Length };
IsPointerOwnedByTagDelegate = new Func<BlamPointer, bool>(virtualTagMemory.Contains);
OnWriteMessage(string.Format("Tag ({0})", tag.Path));
map[tag.Identifier].Seek();
offset = (int)map.Position;
elementArray.VirtualAddress = map[tag.Identifier].Meta.VirtualAddress;
PointersList = new List<Tuple<BlamPointer, ElementArray>>();
ValidateTagBlock(elementArray, elementArray.ToFixedArrayPointer(), binaryReader, ref offset);
AnalyzePointers(PointersList);
stringWriter.Flush();
}
}
Console.WriteLine(string.Format("Parsed ({0})", map.MapName));
//OnWriteMessage(string.Format("End ({0})", map.MapName));
}
}
stringWriter.Close();
return "";
}
public VirtualMemoryStream(string path, int virtualAddress)
: base(File.ReadAllBytes(path))
{
map = new VirtualMappedAddress() { Address = virtualAddress, Length = (int)this.Length, Magic = virtualAddress };
}
public CacheStream(string filename)
: base(filename, FileMode.Open, FileAccess.Read, FileShare.Read, 8 * 1024)
{
//HEADER
var binaryReader = new BinaryReader(this, Encoding.UTF8);
Header = CacheHeader.DeserializeFrom(this);
base.Seek(Header.PathsInfo.PathTableAddress, SeekOrigin.Begin);
var paths = Encoding.UTF8.GetString(binaryReader.ReadBytes(Header.PathsInfo.PathTableLength - 1)).Split(Char.MinValue);
//Halo2.Paths.Assign(paths);
//STRINGS
base.Seek(Header.StringsInfo.StringTableAddress, SeekOrigin.Begin);
Strings = Encoding.UTF8.GetString(binaryReader.ReadBytes(Header.StringsInfo.StringTableLength - 1)).Split(Char.MinValue);
Halo2.Strings.Assign(new List <string>(Strings));
// INDEX
base.Seek(Header.IndexInfo.IndexOffset, SeekOrigin.Begin);
Index = new TagIndex(this, paths);
// Calculate File-pointer magic
var secondaryMagic = Index[Index.GlobalsIdent].VirtualAddress -
(Header.IndexInfo.IndexOffset + Header.IndexInfo.IndexLength);
DefaultMemoryBlock = new VirtualMappedAddress
{
Address = Index[0].VirtualAddress,
Length = Header.IndexInfo.MetaAllocationLength,
Magic = secondaryMagic
};
/* Intent: read the sbsp and lightmap address and lengths from the scenario tag
* and store them in the Tags array.
*/
base.Seek(Index[Index.ScenarioIdent].VirtualAddress - secondaryMagic + 528, SeekOrigin.Begin);
var count = binaryReader.ReadInt32();
var address = binaryReader.ReadInt32();
StructureMemoryBlockBindings = new Dictionary <TagIdent, int>(count * 2);
StructureMemoryBlocks = new List <VirtualMappedAddress>(count);
for (var i = 0; i < count; ++i)
{
base.Seek(address - secondaryMagic + i * 68, SeekOrigin.Begin);
var structureBlockOffset = binaryReader.ReadInt32();
var structureBlockLength = binaryReader.ReadInt32();
var structureBlockAddress = binaryReader.ReadInt32();
base.Seek(8, SeekOrigin.Current);
var sbspIdentifier = binaryReader.ReadTagIdent();
base.Seek(4, SeekOrigin.Current);
var ltmpIdentifier = binaryReader.ReadTagIdent();
base.Seek(structureBlockOffset, SeekOrigin.Begin);
var blockLength = binaryReader.ReadInt32();
var sbspVirtualAddress = binaryReader.ReadInt32();
var ltmpVirtualAddress = binaryReader.ReadInt32();
var sbsp = binaryReader.ReadTagClass();
var hasLightmapData = !TagIdent.IsNull(ltmpIdentifier);
var sbspLength = hasLightmapData ? ltmpVirtualAddress - sbspVirtualAddress : blockLength;
var ltmpLength = blockLength - sbspLength;
var block = new VirtualMappedAddress
{
Address = structureBlockAddress,
Length = structureBlockLength,
Magic = structureBlockAddress - structureBlockOffset
};
var sbspDatum = Index[sbspIdentifier];
sbspDatum.VirtualAddress = sbspVirtualAddress;
sbspDatum.Length = sbspLength;
Index.Update(sbspIdentifier, sbspDatum);
StructureMemoryBlocks.Add(block);
var index = StructureMemoryBlocks.Count - 1;
StructureMemoryBlockBindings[sbspIdentifier] = index;
if (hasLightmapData)
{
var ltmpDatum = Index[ltmpIdentifier];
ltmpDatum.VirtualAddress = ltmpVirtualAddress;
ltmpDatum.Length = ltmpLength;
Index.Update(ltmpIdentifier, ltmpDatum);
StructureMemoryBlockBindings[ltmpIdentifier] = index;
}
ActiveAllocation(StructureCache.VirtualStructureCache0);
}
_deserializedTagCache = new Dictionary <TagIdent, GuerillaBlock>(Index.Count);
_tagHashDictionary = new Dictionary <TagIdent, string>(Index.Count);
Initialize();
}
public bool Validate(MoonfishTagGroup validateTag, IEnumerable <MoonfishTagGroup> tagPool, string[] filenames)
{
error = false;
_pointersList = new List <Tuple <BlamPointer, ElementArray> >();
var filename = string.Format(@"{1}\test_analysis\analysis.txt",
validateTag.Class.ToTokenString(), Local.MapsDirectory);
var stringWriter = File.AppendText(filename);
_writeMessage = (stringWriter.WriteLine);
var offset = 0;
var elementArray = CompileElementArray(validateTag, tagPool, offset);
elementArray.count = 1;
foreach (var file in filenames)
{
using (var map = new CacheStream(file))
{
var binaryReader = new BinaryReader(map);
//OnWriteMessage(string.Format("Begin ({0})", map.MapName));
foreach (var tag in map.Index)
{
error = false;
if (!(tag.Class == validateTag.Class))
{
continue;
}
var metaTableMemory = map.DefaultMemoryBlock;
if (tag.Class == (TagClass)"sbsp" || tag.Class == (TagClass)"ltmp")
{
metaTableMemory =
map.StructureMemoryBlocks[map.StructureMemoryBlockBindings[tag.Identifier]];
map.ActiveAllocation(StructureCache.VirtualStructureCache0 +
map.StructureMemoryBlockBindings[tag.Identifier]);
}
var virtualTagMemory = new VirtualMappedAddress
{
Address = tag.VirtualAddress,
Length = tag.Length
};
_isValidDelegate = metaTableMemory.Contains;
_isPointerOwnedByTagDelegate = virtualTagMemory.Contains;
_pointersList.Clear();
offset = (int)map.Seek(tag.Identifier);
elementArray.virtualAddress = map.Index[tag.Identifier].VirtualAddress;
ValidateTagBlock(elementArray, elementArray.ToFixedArrayPointer(), binaryReader, ref offset);
if (error)
{
OnWriteMessage(string.Format("Tag ({0}.{1})", tag.Path, validateTag.Class.ToTokenString()));
}
stringWriter.Flush();
}
Console.WriteLine(@"Parsed ({0})", map.Header.Name);
}
}
stringWriter.Close();
return(error);
}
