private List <ComPatchClass> ProcessMapFile(VariantConfig variant)
{
var classModell = new List <ComPatchClass>();
ComPatchClass last = null;
foreach (var line in File.ReadAllLines(variant.MappingFile))
{
if (line.StartsWith('#'))
{
Log.Info("Comment: " + line);
continue;
}
if (!line.StartsWith(" ")) //Class
{
last = GetComPatchClassFromLine(line);
classModell.Add(last);
}
else if (last == null)
{
throw new ArgumentException("Didn't find a class for line: " + line);
}
else //Sub
{
ProcessPayloadOfLine(line, last);
}
}
return(classModell);
}
public void ApplyVariant(VariantConfig variant)
{
for (int i = 0; i < Regions.Count; i++)
{
var region = Regions[i];
var vRegionIndex = variant?.RegionLookup[region.SourceIndex] ?? byte.MaxValue;
for (int j = 0; j < region.Permutations.Count; j++)
{
var perm = region.Permutations[j];
if (vRegionIndex != byte.MaxValue)
{
var vRegion = variant.Regions[vRegionIndex];
if (vRegion.Permutations.Count > 0 && !vRegion.Permutations.Any(vp => vp.BasePermutationIndex == perm.SourceIndex))
{
perm.IsVisible = false;
continue;
}
}
perm.IsVisible = true;
}
region.IsVisible = region.Permutations.Any(p => p.IsVisible);
}
}
public bool Run(Configuration config, VariantConfig variantConfig)
{
lock (_lockObject)
{
var deobfTask = Task.Run(() => RunDeobfuscation(config, variantConfig));
deobfTask.Wait();
return(deobfTask.IsCompletedSuccessfully);
}
}
public bool Run(Configuration config, VariantConfig variantConfig)
{
Log.Info($"Extracting Zip starting for '{variantConfig.Name}'");
DirUtil.EnsureCreatedAndClean(variantConfig.OutputFilesDirFolder);
ZipFile.ExtractToDirectory(variantConfig.DecompiledFile, variantConfig.OutputFilesDirFolder);
Log.Info("Extracting Zip finished");
return(true);
}
public ModelConfig ToModelConfig()
{
var config = new ModelConfig();
config.RenderModelTag = RenderModel.Tag;
foreach (var v in Variants)
{
var variant = new VariantConfig
{
Name = v.Name,
RegionLookup = v.RuntimeModelRegions
};
config.Variants.Add(variant);
foreach (var r in v.Regions)
{
var region = new VariantRegionConfig
{
Name = r.Name,
ParentVariantIndex = r.ParentVariantIndex,
BaseRegionIndex = r.RuntimeRegionIndex
};
variant.Regions.Add(region);
foreach (var p in r.Permutations)
{
region.Permutations.Add(new VariantPermutationConfig
{
Name = p.Name,
BasePermutationIndex = p.RenderPermutationIndex
});
}
}
foreach (var att in v.Attachments)
{
variant.Attachments.Add(new AttachmentConfig
{
ParentMarker = att.ParentMarker,
ChildMarker = att.ChildMarker,
ChildVariant = att.ChildVariant,
ChildTag = att.ChildObject.Tag
});
}
}
return(config);
}
private void RunDeobfuscation(Configuration config, VariantConfig variant)
{
Log.Info($"Deobfusctor starting for '{variant.Name}'");
DirUtil.EnsureCreatedAndClean(Directory.GetParent(variant.DeObfuscatedFile).ToString());
var formattedBaseCommand = config.BaseDeobfuscatorCommand
.Replace("{Deobfuscator}", config.Deobfuscator)
.Replace("{SrcJar}", variant.SrcJar)
.Replace("{PatchFile}", variant.PatchFile)
.Replace("{DeObfuscatedFile}", variant.DeObfuscatedFile);
var command = $"{formattedBaseCommand}{(variant.ExcludedComponents.Count > 0 ? $" -ec {string.Join(",",variant.ExcludedComponents)}" : "")}";
if (!ProcessUtil.RunProcess(config.JavaExePath, command, config.DeobfuscatorTimeout))
{
throw new TaskCanceledException();
}
Log.Info("Deobfusctor finished");
}
public ObjectModel3D(ModelFactory factory, ModelConfig config, string name, string defaultVariant)
{
this.config = config;
ModelName = name;
this.defaultVariant = config.Variants.FirstOrDefault(v => v.Name == defaultVariant) ?? config.Variants.FirstOrDefault();
attachments = new Dictionary <string, List <ObjectModel3D> >();
if (config.RenderModelTag == null)
{
baseModel = RenderModel3D.Error("null");
}
else
{
baseModel = factory.CreateRenderModel(config.RenderModelTag.Id);
}
foreach (var variant in config.Variants)
{
var children = new List <ObjectModel3D>();
foreach (var attachment in variant.Attachments.Where(att => att.ChildTag != null))
{
var child = factory.CreateObjectModel(attachment.ChildTag.Id);
if (child.config.RenderModelTag == null)
{
continue;
}
var parentProps = factory.GetProperties(config.RenderModelTag.Id);
var childProps = factory.GetProperties(child.config.RenderModelTag.Id);
child.Transform = GetAttachmentTransform(parentProps, attachment.ParentMarker, childProps, attachment.ChildMarker);
child.SetVariant(attachment.ChildVariant);
children.Add(child);
}
attachments.Add(variant.Name, children);
}
SetVariant(DefaultVariant);
}
private void RunDecompiler(Configuration config, VariantConfig variant)
{
Log.Info($"Decompiler starting for '{variant.Name}'");
var parent = Directory.GetParent(variant.DecompiledFile).ToString();
DirUtil.EnsureCreatedAndClean(parent);
var formattedBaseCommand = config.BaseDecompilerCommand
.Replace("{Decompiler}", config.Decompiler)
.Replace("{SrcFile}", variant.DeObfuscatedFile)
.Replace("{TargetDir}", parent);
var command = $"{formattedBaseCommand}";
if (!ProcessUtil.RunProcess(config.JavaExePath, command, config.DecompilerTimeout))
{
throw new TaskCanceledException();
}
Log.Info("Decompiler finished");
}
public void GeneratePatchFile(VariantConfig variant)
{
Log.Info($"Starting generation of patchfile for {variant.Name}");
var sw = Stopwatch.StartNew();
var patchFiles = ProcessMapFile(variant);
if (Config.MakeJavaCompatible)
{
patchFiles = MakeJavaCompatible(patchFiles, variant);
}
var sb = new StringBuilder();
foreach (var patchFile in patchFiles)
{
sb.Append($"{patchFile.Name} -> {patchFile.ObfName}:");
sb.AppendLine();
foreach (var field in patchFile.Fields)
{
sb.Append($" {field.Type} {field.Name} -> {field.ObfName}");
sb.AppendLine();
}
foreach (var method in patchFile.Methods)
{
sb.Append($" {method.ReturnType} {method.Name}({string.Join(',', method.Parameters.Select(x => x.Type))}) -> {method.ObfName}");
sb.AppendLine();
}
}
File.WriteAllText(variant.PatchFile, sb.ToString());
sw.Stop();
Log.Info($"Generation of patchFile[='{variant.PatchFile}'] for {variant.Name} finished; took {sw.ElapsedMilliseconds}ms for {patchFiles.Count}x classes");
}
private List <ComPatchClass> MakeJavaCompatible(List <ComPatchClass> comPatchClasses, VariantConfig variant)
{
Log.Info($"['{variant.Name}'] Starting making Java compatible");
var renamedClassNames = new Dictionary <string, string>();
foreach (ComPatchClass patchClass in comPatchClasses)
{
var(renamed, newValue) = RenameNameOfPatchClass(patchClass.Name);
if (!renamed)
{
continue;
}
renamedClassNames.Add(patchClass.Name, newValue);
patchClass.Name = newValue;
}
Log.Info($"['{variant.Name}'] Renamed {renamedClassNames.Count}x classes");
int renOccureCount = 0;
foreach (ComPatchClass patchClass in comPatchClasses)
{
foreach (var method in patchClass.Methods)
{
foreach (var methodParameter in method.Parameters)
{
var(isPatchPar, newValuePar) = ShouldPatchClassName(renamedClassNames, methodParameter.Type);
if (isPatchPar)
{
renOccureCount++;
methodParameter.Type = newValuePar;
}
}
var(isPatchRet, newValueRet) = ShouldPatchClassName(renamedClassNames, method.ReturnType);
if (isPatchRet)
{
renOccureCount++;
method.ReturnType = newValueRet;
}
}
}
Log.Info($"['{variant.Name}'] Renamed {renOccureCount}x occurrences of the classes");
Log.Info($"['{variant.Name}'] Finished making Java compatible");
return(comPatchClasses);
}
