public static EmitResult Compile(GameRelease release, string assemblyName, string code, CancellationToken cancel, out MemoryStream assemblyStream)
{
var gameCategory = release.ToCategory();
StringBuilder sb = new StringBuilder();
sb.AppendLine($"using System;");
sb.AppendLine($"using Noggog;");
sb.AppendLine($"using System.Threading;");
sb.AppendLine($"using System.Threading.Tasks;");
sb.AppendLine($"using System.Linq;");
sb.AppendLine($"using System.IO;");
sb.AppendLine($"using System.Collections;");
sb.AppendLine($"using System.Collections.Generic;");
sb.AppendLine($"using Mutagen.Bethesda.Synthesis;");
sb.AppendLine($"using Mutagen.Bethesda;");
sb.AppendLine($"using Mutagen.Bethesda.{release.ToCategory()};");
sb.AppendLine($"public class {ClassName}");
sb.AppendLine("{");
sb.AppendLine($"public async Task Run(Mutagen.Bethesda.Synthesis.SynthesisState<Mutagen.Bethesda.{gameCategory}.I{gameCategory}Mod, Mutagen.Bethesda.{gameCategory}.I{gameCategory}ModGetter> state)");
sb.AppendLine("{");
sb.AppendLine(code);
sb.AppendLine("}");
sb.AppendLine("}");
code = sb.ToString();
SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(code);
var options = new CSharpCompilationOptions(
OutputKind.DynamicallyLinkedLibrary,
optimizationLevel: OptimizationLevel.Release);
Compilation compilation = CSharpCompilation.Create(assemblyName: assemblyName, options: options)
.AddSyntaxTrees(syntaxTree)
.AddReferences(new[]
{
MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Task).Assembly.Location),
MetadataReference.CreateFromFile(typeof(File).Assembly.Location),
MetadataReference.CreateFromFile(Assembly.Load("netstandard").Location),
MetadataReference.CreateFromFile(Assembly.Load("System.Runtime").Location),
MetadataReference.CreateFromFile(Assembly.Load("Loqui").Location),
MetadataReference.CreateFromFile(Assembly.Load("Noggog.CSharpExt").Location),
MetadataReference.CreateFromFile(Assembly.Load("Mutagen.Bethesda.Kernel").Location),
MetadataReference.CreateFromFile(Assembly.Load("Mutagen.Bethesda.Core").Location),
MetadataReference.CreateFromFile(Assembly.Load("Mutagen.Bethesda.Synthesis").Location),
});
foreach (var game in EnumExt.GetValues <GameCategory>())
{
compilation = compilation.AddReferences(MetadataReference.CreateFromFile(Assembly.Load($"Mutagen.Bethesda.{game}").Location));
}
assemblyStream = new MemoryStream();
return(compilation.Emit(assemblyStream, cancellationToken: cancel));
}
public object Create(object request, ISpecimenContext context)
{
if (request is SeededRequest seed)
{
request = seed.Request;
}
if (request is not Type t)
{
return(new NoSpecimen());
}
if (t == typeof(IGameReleaseContext))
{
var ret = Substitute.For <IGameReleaseContext>();
ret.Release.Returns(_release);
return(ret);
}
else if (t == typeof(IGameCategoryContext))
{
var ret = Substitute.For <IGameCategoryContext>();
ret.Category.Returns(_release.ToCategory());
return(ret);
}
else if (t == typeof(IGameDirectoryProvider))
{
return(new GameDirectoryInjection(GameDirectory));
}
else if (t == typeof(IDataDirectoryProvider))
{
var dir = context.Create <IGameDirectoryProvider>();
var ret = Substitute.For <IDataDirectoryProvider>();
ret.Path.Returns(x =>
{
return(new DirectoryPath(Path.Combine(dir.Path, "DataDirectory")));
});
return(ret);
}
else if (t == typeof(MockFileSystem))
{
if (_mockFileSystem == null)
{
_mockFileSystem = new NoggogMockFileSystem(
new Dictionary <string, MockFileData>(),
fileSystemWatcher: context.Create <IFileSystemWatcherFactory>());
_mockFileSystem.Directory.CreateDirectory(PathBuilder.ExistingDirectory);
_mockFileSystem.File.Create(PathBuilder.ExistingFile);
_mockFileSystem.Directory.CreateDirectory(Path.Combine(GameDirectory, "DataDirectory"));
_mockFileSystem.File.Create(Path.Combine(PathBuilder.ExistingDirectory, "Plugins.txt"));
_mockFileSystem.File.Create(Path.Combine(GameDirectory, $"{_release.ToCategory()}.ccc"));
}
return(_mockFileSystem);
}
return(new NoSpecimen());
}
public static GameEnvironmentState <TModSetter, TModGetter> Construct(
GameRelease release,
DirectoryPath dataFolder,
LinkCachePreferences?linkCachePrefs = null)
{
var dataPath = Path.Combine(dataFolder.Path, "Data");
var loadOrder = Mutagen.Bethesda.Plugins.Order.LoadOrder.Import <TModGetter>(
dataPath,
Mutagen.Bethesda.Plugins.Order.LoadOrder.GetListings(release, dataPath),
release);
if (!PluginListings.TryGetListingsFile(release, out var loadOrderFilePath))
{
throw new FileNotFoundException("Could not locate plugins file");
}
var ccPath = CreationClubListings.GetListingsPath(release.ToCategory(), dataPath);
return(new GameEnvironmentState <TModSetter, TModGetter>(
dataFolderPath: dataFolder,
loadOrderFilePath: loadOrderFilePath.Path,
creationKitLoadOrderFilePath: ccPath,
loadOrder: loadOrder,
linkCache: loadOrder.ToImmutableLinkCache <TModSetter, TModGetter>(linkCachePrefs),
dispose: true));
}
internal static Func <RunSynthesisMutagenPatcher, PatcherPreferences?, ModKey, IPatcherState> ConstructStateFactory(GameRelease release)
{
var regis = release.ToCategory().ToModRegistration();
var cliSettingsParam = Expression.Parameter(typeof(RunSynthesisMutagenPatcher));
var userPrefs = Expression.Parameter(typeof(PatcherPreferences));
var modKey = Expression.Parameter(typeof(ModKey));
MethodCallExpression callExp = Expression.Call(
typeof(Mutagen.Bethesda.Synthesis.Internal.Utility),
nameof(Mutagen.Bethesda.Synthesis.Internal.Utility.ToState),
new Type[]
{
regis.SetterType,
regis.GetterType,
},
cliSettingsParam,
userPrefs,
modKey);
LambdaExpression lambda = Expression.Lambda(callExp, cliSettingsParam, userPrefs, modKey);
var deleg = lambda.Compile();
return((RunSynthesisMutagenPatcher settings, PatcherPreferences? prefs, ModKey modKey) =>
{
return (IPatcherState)deleg.DynamicInvoke(settings, prefs, modKey) !;
});
}
public static string GetArchiveExtension(GameRelease release)
{
switch (release.ToCategory())
{
case GameCategory.Oblivion:
case GameCategory.Skyrim:
return(".bsa");
case GameCategory.Fallout4:
return(".ba2");
default:
throw new NotImplementedException();
}
}
public static IModGetter Importer(ModPath path, GameRelease release)
{
var regis = release.ToCategory().ToModRegistration();
return(ModInstantiatorReflection.GetOverlay(regis)(path, release));
}
public void TestPex(GameRelease release, ReadOnlyMemorySlice <byte> bytes)
{
var memStream = new BinaryMemoryReadStream(bytes);
PexFile.CreateFromStream(memStream, release.ToCategory());
}
