private void ProcessCarList(Chunk chunk)
{
var newSize = chunk.Size - Reader.AlignToBoundary(0x10);
if (newSize % 0xD0 != 0)
{
throw new InvalidDataException("Malformed car list chunk");
}
Progress?.Report("Processing car list");
while (Stream.Position < chunk.EndOffset)
{
var cti = BinaryHelpers.ReadStruct <CarTypeInfo>(Reader);
//Debug.WriteLine("{0} {1} ({2})", cti.ManufacturerName, cti.BaseModelName, cti.UsageType);
var acr = new AaronCarRecord();
acr.BaseModelName = cti.BaseModelName;
acr.CarTypeName = cti.CarTypeName;
acr.ManufacturerName = cti.ManufacturerName;
acr.DefaultBasePaint = cti.DefaultBasePaint;
acr.DefaultSkinNumber = cti.DefaultSkinNumber;
acr.Skinnable = cti.Skinnable;
acr.UsageType = cti.UsageType;
_carService.AddCar(acr);
HashResolver.Add(cti.CarTypeNameHash, cti.CarTypeName);
}
this.GenerateHashes();
}
private AaronCarPartAttribute ConvertAttribute(CarPartAttribute rawAttribute)
{
AaronCarPartAttribute attribute = new AaronCarPartAttribute();
attribute.Name = HashResolver.Resolve(rawAttribute.NameHash);
switch (attribute.Name)
{
case "TEXTURE":
case "LOD_CHARACTERS_OFFSET":
case "NAME_OFFSET":
this.LoadSingleAttribString(attribute, rawAttribute);
break;
case "LOD_BASE_NAME":
this.LoadDoubleAttribString(attribute, rawAttribute);
break;
default:
//attribute.Value = rawAttribute.iParam;
this.SetAttributeValue(attribute, rawAttribute);
break;
}
return(attribute);
}
public override void Read(BinaryReader br)
{
this.ClassHash = br.ReadUInt32();
this.RowNameHash = br.ReadUInt32();
br.ReadInt32();
this.Class = HashResolver.Resolve(this.ClassHash);
this.RowName = HashResolver.Resolve(this.RowNameHash);
}
public override void Read(BinaryReader br)
{
ClassHash = br.ReadUInt32();
RowNameHash = br.ReadUInt32();
Factor = br.ReadSingle();
Class = HashResolver.Resolve(ClassHash);
RowName = HashResolver.Resolve(RowNameHash);
}
public override string ToString()
{
return($"{nameof(UnknownRpc)}(" +
$"{nameof(NetId)}: {NetId.Value}, " +
(Name != null
? $"{nameof(Name)}: {Name}, "
: $"{nameof(Hash)}: {HashResolver.LookupRpc(Hash)}, ") +
$"{nameof(Payload)}: {Convert.ToBase64String(Payload)}" +
")");
}
public override void Read(BinaryReader br)
{
ClassHash = br.ReadUInt32();
RowNameHash = br.ReadUInt32();
br.ReadInt32();
Level = br.ReadUInt32();
Class = HashResolver.Resolve(ClassHash);
RowName = HashResolver.Resolve(RowNameHash);
}
private void ProcessCarHashList(Chunk chunk)
{
if (chunk.Size % 4 != 0)
{
throw new InvalidDataException("malformed car hash list chunk");
}
Progress?.Report("Processing car part collection hash list");
while (Stream.Position < chunk.EndOffset)
{
AaronCarPartCollection carPartCollection = new AaronCarPartCollection();
carPartCollection.Name = HashResolver.Resolve(Reader.ReadUInt32());
carPartCollection.Parts = new SynchronizedObservableCollection <AaronCarPartRecord>();
this._carPartService.AddCarPartCollection(carPartCollection);
}
}
private void OnExecute()
{
Application.Init();
var app = new Application("EvoS.PacketInspector", GLib.ApplicationFlags.NonUnique);
app.Register(GLib.Cancellable.Current);
// We require data from the game assets, so ensure we have a valid data path
if (!AssetLoader.FindAssetRoot(Settings.AtlasReactorData))
{
using var settingsUi = new SettingsUi();
settingsUi.Show();
app.AddWindow(settingsUi);
var x = (ResponseType)settingsUi.Run();
if (x != ResponseType.Ok)
{
return;
}
}
HashResolver.Init(AssetLoader.BasePath);
Patcher.ResolveSyncListFields();
Patcher.PatchAll();
var win = new MainWindow();
if (!PacketsDir.IsNullOrEmpty())
{
win.LoadPacketDump(PacketDumpType.PacketDirectory, PacketsDir);
}
else if (!ReplayFile.IsNullOrEmpty())
{
win.LoadPacketDump(PacketDumpType.ReplayFile, ReplayFile);
}
app.AddWindow(win);
win.Show();
Application.Run();
}
private void GenerateHashes()
{
Progress?.Report("Building hash table");
DebugTiming.BeginTiming("GenerateHashes");
var racerHashes = AaronHashLists.Get("RacerHashes");
var copHashes = AaronHashLists.Get("CopHashes");
var trafficHashes = AaronHashLists.Get("TrafficHashes");
foreach (var aaronCarRecord in _carService.GetCarsByType(CarUsageType.Racing))
{
//Debug.WriteLine($"Add racer hashes for {aaronCarRecord.CarTypeName}");
foreach (var hashText in racerHashes.Select(s => s.Replace("%", aaronCarRecord.CarTypeName)))
{
HashResolver.Add(Hashing.BinHash(hashText), hashText);
}
}
foreach (var aaronCarRecord in _carService.GetCarsByType(CarUsageType.Cop))
{
//Debug.WriteLine($"Add cop hashes for {aaronCarRecord.CarTypeName}");
foreach (var hashText in copHashes.Select(s => s.Replace("%", aaronCarRecord.CarTypeName)))
{
//Debug.WriteLine(hashText);
HashResolver.Add(Hashing.BinHash(hashText), hashText);
}
}
foreach (var aaronCarRecord in _carService.GetCarsByType(CarUsageType.Traffic))
{
//Debug.WriteLine($"Add traffic hashes for {aaronCarRecord.CarTypeName}");
foreach (var hashText in trafficHashes.Select(s => s.Replace("%", aaronCarRecord.CarTypeName)))
{
//Debug.WriteLine(hashText);
HashResolver.Add(Hashing.BinHash(hashText), hashText);
}
}
DebugTiming.EndTiming("GenerateHashes");
}
private void ProcessCarPartTable(Chunk chunk)
{
if (chunk.Size % 0xC != 0)
{
throw new InvalidDataException("Malformed car part table chunk");
}
DebugTiming.BeginTiming("ProcessCarPartTable");
Progress?.Report("Processing car parts");
List <AaronCarPartAttribute> attributes = new List <AaronCarPartAttribute>();
var allCollections = _carPartService.GetCarPartCollections();
Dictionary <int, AaronCarPartCollection> collectionsDict =
allCollections.ToDictionary(c => allCollections.IndexOf(c), c => c);
while (Stream.Position < chunk.EndOffset)
{
DBCarPart dbCarPart = BinaryHelpers.ReadStruct <DBCarPart>(Reader);
var part = new AaronCarPartRecord();
part.Name = HashResolver.Resolve(dbCarPart.Hash);
part.Attributes = this.PrepareAttributes(dbCarPart);
attributes.AddRange(part.Attributes);
//_carPartService.GetCarPartCollections()
collectionsDict[dbCarPart.CarIndex].Parts.Add(part);
//_carPartService.GetCarPartCollectionByIndex(dbCarPart.CarIndex).Parts.Add(part);
}
var uniqueAttribs = attributes.DistinctBy(a => a.GetHashCode()).Count();
DebugTiming.EndTiming("ProcessCarPartTable");
// we can discard internal attribute data now
_attributeOffsetTables.Clear();
_attributes.Clear();
}
private void ProcessDataTable(Chunk chunk)
{
Progress?.Report("Processing data table");
Stream.Align(0x10);
var table = new AaronDataTable();
table.Name = HashResolver.Resolve(Reader.ReadUInt32());
table.Entries = new List <AaronDataTableEntry>();
while (Stream.Position < chunk.EndOffset)
{
var entry = new AaronDataTableEntry();
entry.Name = HashResolver.Resolve(Reader.ReadUInt32());
entry.Unknown = Reader.ReadUInt32();
entry.Unknown2 = Reader.ReadSingle();
table.Entries.Add(entry);
}
_dataTableService.AddDataTable(table);
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
// Load hash lists
AaronHashLists.Load("GenericHashes", @"ApplicationData\HashLists\GenericHashes.txt");
AaronHashLists.Load("RacerHashes", @"ApplicationData\HashLists\RacerHashes.txt");
AaronHashLists.Load("CopHashes", @"ApplicationData\HashLists\CopHashes.txt");
AaronHashLists.Load("TrafficHashes", @"ApplicationData\HashLists\TrafficHashes.txt");
// Register all generic hashes immediately
foreach (var hashText in AaronHashLists.Get("GenericHashes"))
{
HashResolver.Add(Hashing.BinHash(hashText), hashText);
}
if (Directory.Exists(@"ApplicationData\CustomHashLists"))
{
foreach (var file in Directory.GetFiles(@"ApplicationData\CustomHashLists", "*.txt",
SearchOption.TopDirectoryOnly))
{
AaronHashLists.Load(Path.GetFileNameWithoutExtension(file), file);
foreach (var s in AaronHashLists.Get(Path.GetFileNameWithoutExtension(file)))
{
HashResolver.Add(Hashing.BinHash(s), s);
}
}
}
// Load templates
AaronCarTemplates.LoadFromFile("CAR_COP", @"ApplicationData\Templates\CarTemplate_COP.json");
AaronCarTemplates.LoadFromFile("CAR_RACER", @"ApplicationData\Templates\CarTemplate_RACER.json");
AaronCarTemplates.LoadFromFile("CAR_TRAFFIC", @"ApplicationData\Templates\CarTemplate_TRAFFIC.json");
// Load other data
AaronManufacturers.LoadFromFile(@"ApplicationData\Manufacturers.txt");
}
public override void Read(BinaryReader br)
{
this.Hash = br.ReadUInt32();
this.Value = HashResolver.Resolve(this.Hash);
}
public override void Read(BinaryReader br)
{
Hash = br.ReadUInt32();
Value = HashResolver.Resolve(Hash);
}
