protected abstract CecilAssemblyOutput ConvertAssembly(PapyrusAssemblyInput input);
protected override ClrAssemblyOutput ConvertAssembly(PapyrusAssemblyInput input)
{
var exeAsm = Assembly.GetExecutingAssembly();
var assemblyName = NamespaceResolver.Resolve("Core");
assembly = Thread.GetDomain().DefineDynamicAssembly(
new AssemblyName(assemblyName),
AssemblyBuilderAccess.RunAndSave, outputDirectory);
mainModule = assembly.DefineDynamicModule(assemblyName, assemblyName + ".dll");
var i = 1;
var x = Console.CursorLeft;
var y = Console.CursorTop;
foreach (var inputAssembly in input.Assemblies)
{
Console.SetCursorPosition(x, y);
Console.WriteLine("Adding assembly references... " + i++ + "/" + input.Assemblies.Length);
PrepareTypes(inputAssembly);
}
foreach (var inputAssembly in input.Assemblies)
{
foreach (var ptype in inputAssembly.Types)
{
foreach (var type in DefinedTypes)
{
var targetBaseType =
ReferenceTypes.FirstOrDefault(t => t.Name.ToLower() == ptype.BaseTypeName.Value.ToLower());
if (targetBaseType != null)
{
type.SetParent(targetBaseType);
}
}
}
}
i = 1;
Console.SetCursorPosition(0, y + 1);
foreach (var papyrusAssembly in input.Assemblies)
{
foreach (var type in papyrusAssembly.Types)
{
Console.SetCursorPosition(0, y + 1);
Console.WriteLine("Building Classes... " + i++ + "/" + input.Assemblies.Length);
var definedType = DefinedTypes.FirstOrDefault(n => n.Name == type.Name.Value);
if (definedType == null)
{
definedType = mainModule.DefineType(type.Name.Value,
TypeAttributes.Public);
}
BuildType(definedType, type);
}
}
foreach (var t in DefinedTypes)
{
t.CreateType();
}
//exeAsm.FindTypes("attribute")
// .ForEach(attr => ImportType(mainModule, attr));
Console.WriteLine("Process Completed.");
return(new ClrAssemblyOutput(assembly));
}
protected override CecilAssemblyOutput ConvertAssembly(PapyrusAssemblyInput input)
{
var exeAsm = Assembly.GetExecutingAssembly();
var name = "Core";
clrAssembly = AssemblyDefinition.CreateAssembly(
new AssemblyNameDefinition(NamespaceResolver.Resolve(name),
new Version(2, 0)), NamespaceResolver.Resolve(name), ModuleKind.Dll);
mainModule = clrAssembly.MainModule;
objectType = mainModule.Import(typeof(object));
int i = 1, ij = 0;
userInterface.DrawInterface("(2/3) Adding assembly references.");
foreach (var inputAssembly in input.Assemblies)
{
var redrawProgress = ij >= 100 || i == input.Assemblies.Length || input.Assemblies.Length < 500;
if (redrawProgress)
{
//Console.SetCursorPosition(x, y);
//Console.WriteLine("Adding assembly references... " + i + "/" + input.Assemblies.Length);
userInterface.DrawProgressBarWithInfo(i, input.Assemblies.Length);
ij = 0;
}
ij++;
i++;
AddAssemblyReferences(inputAssembly);
}
i = 1;
ij = 0;
//Console.SetCursorPosition(0, y + 1);
userInterface.DrawInterface("(3/3) Creating CLR types.");
foreach (var papyrusAssembly in input.Assemblies)
{
foreach (var type in papyrusAssembly.Types)
{
var redrawProgress = ij >= 100 || i == input.Assemblies.Length || input.Assemblies.Length < 500;
if (redrawProgress)
{
//Console.SetCursorPosition(0, y + 1);
//Console.WriteLine("Building Classes... " + i + "/" + input.Assemblies.Length);
userInterface.DrawProgressBarWithInfo(i, input.Assemblies.Length);
ij = 0;
}
ij++;
i++;
AddTypeDefinition(null, type.Name, type, false);
}
}
exeAsm.FindTypes("attribute")
.ForEach(attr => ImportType(mainModule, attr));
userInterface.DrawResult("Building Core Library Completed.");
return(new CecilAssemblyOutput(clrAssembly));
}
protected abstract MultiCSharpOutput ConvertAssembly(PapyrusAssemblyInput input);
public int Run()
{
IAssemblyConverter converter;
IAssemblyInput inputData;
if (args.Length < 2)
{
// ui.WriteLine(" Missing Important Arguments.");
ui.DrawHelp();
return(128);
}
ui.Clear();
ui.DrawInterface("Magic is about to happen!");
var clr2Papyrus = !Enumerable.Contains(args, "-clr");
var input = args[0];
if (args.Contains("-i"))
{
input = args[Array.IndexOf(args, "-i") + 1];
}
var output = args[1];
if (args.Contains("-o"))
{
output = args[Array.IndexOf(args, "-o") + 1];
}
var autoClose = args.Contains("x") || args.Contains("X") || args.Contains("-x") || args.Contains("-X");
if (clr2Papyrus)
{
var targetVersion = Enumerable.Contains(args, "-skyrim")
? PapyrusVersionTargets.Skyrim
: PapyrusVersionTargets.Fallout4;
var compilerOptions = !Enumerable.Contains(args, "-easy")
? PapyrusCompilerOptions.Strict
: PapyrusCompilerOptions.Easy;
var readerParameters = new ReaderParameters {
ReadSymbols = true
};
converter = new Clr2PapyrusConverter(ui, instructorProcessor, compilerOptions);
var assemblyDefinition = AssemblyDefinition.ReadAssembly(input, readerParameters);
assemblyDefinition.MainModule.ReadSymbols();
inputData = new ClrAssemblyInput(assemblyDefinition, targetVersion);
}
else
{
var nsResolver = new NamespaceResolver();
//var camelCaseResolver = new PascalCaseNameResolver(ui, "wordlist-fo4.txt");
// Papyrus2ClrCecilConverter
converter = new Papyrus2ClrCecilConverter(
ui, nameResolver, nsResolver,
new TypeReferenceResolver(nsResolver, new TypeNameResolver(nameResolver)));
var pexFiles = Directory.GetFiles(input, "*.pex", SearchOption.AllDirectories);
ui.DrawInterface("(1/3) Reading Papyrus Assemblies.");
var papyrusAssemblyDefinitions = pexFiles.Select(f => ReadPapyrusAssembly(f, pexFiles.Length)).ToArray();
inputData = new PapyrusAssemblyInput(
papyrusAssemblyDefinitions
);
}
var outputData = converter.Convert(inputData);
if (outputData != null)
{
outputData.Save(output);
// Do something...
}
if (autoClose)
{
return(0);
}
while (true)
{
var openTargetDir = new Hotkeys("Open target directory", ConsoleKey.A, () => { Process.Start(output); });
var exit = new Hotkeys("Exit", ConsoleKey.X, () => { });
ui.DrawHotkeys(openTargetDir, exit);
var posx = Console.CursorLeft;
var k = Console.ReadKey();
Console.CursorLeft = posx;
Console.Write(" ");
if (k.Key == exit.Key)
{
return(0);
}
if (k.Key == openTargetDir.Key)
{
openTargetDir.Action();
}
}
}
protected override MultiCSharpOutput ConvertAssembly(PapyrusAssemblyInput input)
{
return(new MultiCSharpOutput(input.Assemblies.Select(CreateCSharpDump).ToList()));
}
