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); }