431 lines
19 KiB
C#
431 lines
19 KiB
C#
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Immutable;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Xml.Linq;
|
|
using Barotrauma.Extensions;
|
|
using Barotrauma.LuaCs.Data;
|
|
using FluentResults;
|
|
using Microsoft.Toolkit.Diagnostics;
|
|
using MoonSharp.VsCodeDebugger.SDK;
|
|
|
|
namespace Barotrauma.LuaCs;
|
|
|
|
public sealed class ModConfigService : IModConfigService
|
|
{
|
|
private IStorageService _storageService;
|
|
private ILoggerService _logger;
|
|
private IParserServiceAsync<ResourceParserInfo, IAssemblyResourceInfo> _assemblyParserService;
|
|
private IParserServiceAsync<ResourceParserInfo, ILuaScriptResourceInfo> _luaScriptParserService;
|
|
private IParserServiceAsync<ResourceParserInfo, IConfigResourceInfo> _configParserService;
|
|
#if CLIENT
|
|
private IParserServiceAsync<ResourceParserInfo, IStylesResourceInfo> _stylesParserService;
|
|
#endif
|
|
private readonly AsyncReaderWriterLock _operationsLock = new();
|
|
|
|
public ModConfigService(IStorageService storageService,
|
|
IParserServiceAsync<ResourceParserInfo, IAssemblyResourceInfo> assemblyParserService,
|
|
IParserServiceAsync<ResourceParserInfo, ILuaScriptResourceInfo> luaScriptParserService,
|
|
IParserServiceAsync<ResourceParserInfo, IConfigResourceInfo> configParserService,
|
|
#if CLIENT
|
|
IParserServiceAsync<ResourceParserInfo, IStylesResourceInfo> stylesParserService,
|
|
#endif
|
|
ILoggerService logger)
|
|
{
|
|
_storageService = storageService;
|
|
_assemblyParserService = assemblyParserService;
|
|
_luaScriptParserService = luaScriptParserService;
|
|
_configParserService = configParserService;
|
|
_logger = logger;
|
|
#if CLIENT
|
|
_stylesParserService = stylesParserService;
|
|
#endif
|
|
}
|
|
|
|
#region Dispose
|
|
|
|
public void Dispose()
|
|
{
|
|
using var lck = _operationsLock.AcquireWriterLock().ConfigureAwait(false).GetAwaiter().GetResult();
|
|
if (!ModUtils.Threading.CheckIfClearAndSetBool(ref _isDisposed))
|
|
return;
|
|
|
|
try
|
|
{
|
|
_storageService.Dispose();
|
|
_logger.Dispose();
|
|
_assemblyParserService.Dispose();
|
|
_luaScriptParserService.Dispose();
|
|
_configParserService.Dispose();
|
|
|
|
_storageService = null;
|
|
_logger = null;
|
|
_assemblyParserService = null;
|
|
_luaScriptParserService = null;
|
|
_configParserService = null;
|
|
|
|
#if CLIENT
|
|
_stylesParserService.Dispose();
|
|
_stylesParserService = null;
|
|
#endif
|
|
}
|
|
catch
|
|
{
|
|
// ignored
|
|
}
|
|
}
|
|
|
|
private int _isDisposed = 0;
|
|
public bool IsDisposed
|
|
{
|
|
get => ModUtils.Threading.GetBool(ref _isDisposed);
|
|
private set => ModUtils.Threading.SetBool(ref _isDisposed, value);
|
|
}
|
|
|
|
#endregion
|
|
|
|
public async Task<Result<IModConfigInfo>> CreateConfigAsync(ContentPackage src)
|
|
{
|
|
Guard.IsNotNull(src, nameof(src));
|
|
using var lck = await _operationsLock.AcquireReaderLock();
|
|
IService.CheckDisposed(this);
|
|
|
|
if (await TryGetModConfigXmlAsync(src) is { IsSuccess: true, Value: { } config })
|
|
{
|
|
return await CreateFromConfigXmlAsync(src, config);
|
|
}
|
|
|
|
return await CreateFromLegacyAsync(src);
|
|
}
|
|
|
|
public async Task<ImmutableArray<(ContentPackage Source, Result<IModConfigInfo> Config)>> CreateConfigsAsync(ImmutableArray<ContentPackage> src)
|
|
{
|
|
if (src.IsDefaultOrEmpty)
|
|
ThrowHelper.ThrowArgumentNullException($"{nameof(CreateConfigsAsync)}: The supplied array is default or empty!");
|
|
using var lck = await _operationsLock.AcquireReaderLock();
|
|
IService.CheckDisposed(this);
|
|
|
|
var builder = ImmutableArray.CreateBuilder<Task<Task<Result<IModConfigInfo>>>>(src.Length);
|
|
foreach (var srcItem in src)
|
|
{
|
|
builder.Add(Task.Factory.StartNew(async Task<Result<IModConfigInfo>> () => await CreateConfigAsync(srcItem)));
|
|
}
|
|
var taskResults = await Task.WhenAll(builder.ToImmutable());
|
|
var returnResults = ImmutableArray.CreateBuilder<(ContentPackage Source, Result<IModConfigInfo> Config)>();
|
|
foreach (var taskResult in taskResults)
|
|
{
|
|
if (taskResult.IsFaulted)
|
|
{
|
|
ThrowHelper.ThrowInvalidOperationException($"{nameof(CreateConfigsAsync)}: Task failed: {taskResult.Exception?.Message}");
|
|
}
|
|
|
|
var r = await taskResult;
|
|
returnResults.Add((r.Value.Package, r));
|
|
}
|
|
|
|
return returnResults.ToImmutable();
|
|
}
|
|
|
|
//--- Helpers
|
|
private async Task<Result<XElement>> TryGetModConfigXmlAsync(ContentPackage src)
|
|
{
|
|
return await _storageService.LoadPackageXmlAsync(ContentPath.FromRaw(src, "%ModDir%/ModConfig.xml")) is { IsSuccess: true, Value: { Root: {} config} }
|
|
? FluentResults.Result.Ok(config)
|
|
: FluentResults.Result.Fail<XElement>("ModConfig.xml not found");
|
|
}
|
|
|
|
private async Task<Result<IModConfigInfo>> CreateFromConfigXmlAsync(ContentPackage owner, XElement src)
|
|
{
|
|
var asmTask = Task.Factory.StartNew(async () => await GetAssembliesFromXml(owner, src));
|
|
var cfgTask = Task.Factory.StartNew(async () => await GetConfigsFromXml(owner, src));
|
|
var luaTask = Task.Factory.StartNew(async () => await GetLuaScriptsFromXml(owner, src));
|
|
#if CLIENT
|
|
var styleTask = Task.Factory.StartNew(async () => await GetStylesFromXml(owner, src));
|
|
#endif
|
|
|
|
await Task.WhenAll(
|
|
asmTask,
|
|
cfgTask,
|
|
#if CLIENT
|
|
styleTask,
|
|
#endif
|
|
luaTask);
|
|
|
|
return FluentResults.Result.Ok<IModConfigInfo>(new ModConfigInfo()
|
|
{
|
|
Package = owner,
|
|
Assemblies = await await asmTask,
|
|
Configs = await await cfgTask,
|
|
#if CLIENT
|
|
Styles = await await styleTask,
|
|
#endif
|
|
LuaScripts = await await luaTask
|
|
});
|
|
|
|
async Task<ImmutableArray<ILuaScriptResourceInfo>> GetLuaScriptsFromXml(ContentPackage contentPackage,
|
|
XElement cfgElement)
|
|
{
|
|
return await GetResourceFromXml<ILuaScriptResourceInfo>(contentPackage, cfgElement, "Lua", "FileGroup", _luaScriptParserService);
|
|
}
|
|
|
|
async Task<ImmutableArray<IConfigResourceInfo>> GetConfigsFromXml(ContentPackage contentPackage,
|
|
XElement cfgElement)
|
|
{
|
|
return await GetResourceFromXml<IConfigResourceInfo>(contentPackage, cfgElement, "Config", "FileGroup", _configParserService);
|
|
}
|
|
|
|
async Task<ImmutableArray<IAssemblyResourceInfo>> GetAssembliesFromXml(ContentPackage contentPackage,
|
|
XElement cfgElement)
|
|
{
|
|
return await GetResourceFromXml<IAssemblyResourceInfo>(contentPackage, cfgElement, "Assembly", "FileGroup", _assemblyParserService);
|
|
}
|
|
|
|
#if CLIENT
|
|
async Task<ImmutableArray<IStylesResourceInfo>> GetStylesFromXml(ContentPackage contentPackage,
|
|
XElement cfgElement)
|
|
{
|
|
return await GetResourceFromXml<IStylesResourceInfo>(contentPackage, cfgElement, "Style", "FileGroup", _stylesParserService);
|
|
}
|
|
#endif
|
|
|
|
async Task<ImmutableArray<T>> GetResourceFromXml<T>(ContentPackage contentPackage, XElement cfgElement, string elemName, string fileGroupName, IParserServiceAsync<ResourceParserInfo, T> resourceService)
|
|
{
|
|
var elems = GetResourceElementsWithName(owner, cfgElement, elemName, fileGroupName);
|
|
if (elems.IsDefaultOrEmpty)
|
|
return ImmutableArray<T>.Empty;
|
|
|
|
var results = await resourceService.TryParseResourcesAsync(elems);
|
|
Guard.IsNotEmpty((IReadOnlyCollection<Result<T>>)results, nameof(results));
|
|
|
|
var resources = ImmutableArray.CreateBuilder<T>();
|
|
foreach (var result in results)
|
|
{
|
|
if (result.Errors.Count > 0)
|
|
{
|
|
_logger.LogResults(result.ToResult());
|
|
continue;
|
|
}
|
|
resources.Add(result.Value);
|
|
}
|
|
return resources.ToImmutable();
|
|
}
|
|
|
|
ImmutableArray<ResourceParserInfo> GetResourceElementsWithName(ContentPackage package, XElement root, string elemName, string groupName)
|
|
{
|
|
var elems = ImmutableArray.CreateBuilder<ResourceParserInfo>();
|
|
|
|
elems.AddRange(root.GetChildElements(elemName)
|
|
.Select(e => new ResourceParserInfo(package, e, ImmutableArray<Identifier>.Empty, ImmutableArray<Identifier>.Empty))
|
|
.ToImmutableArray());
|
|
|
|
if (root.GetChildElements(groupName).ToImmutableArray() is { IsDefaultOrEmpty: false } fileGroups)
|
|
{
|
|
foreach (var fileGroup in fileGroups)
|
|
{
|
|
if (fileGroup.GetChildElements(elemName).ToImmutableArray() is { IsDefaultOrEmpty: false } subLuaElems)
|
|
{
|
|
var cond = GetDependencyIdentifiers(fileGroup, true);
|
|
var negCond = GetDependencyIdentifiers(fileGroup, false);
|
|
|
|
foreach (var element in subLuaElems)
|
|
{
|
|
elems.Add(new ResourceParserInfo(package, element, cond, negCond));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return elems.ToImmutable();
|
|
}
|
|
|
|
ImmutableArray<Identifier> GetDependencyIdentifiers(XElement fg, bool depsLoadedSetting)
|
|
{
|
|
return fg.GetChildElements("Conditional")
|
|
.Where(cElem => bool.TryParse(cElem.GetAttribute("IsLoaded").Value, out bool isLoaded) && isLoaded == depsLoadedSetting)
|
|
.SelectMany(cElem2 => cElem2.GetAttributeString("Dependencies", String.Empty)
|
|
.Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries)
|
|
.Select(ident => new Identifier(ident)))
|
|
.ToImmutableArray();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
private async Task<Result<IModConfigInfo>> CreateFromLegacyAsync(ContentPackage src)
|
|
{
|
|
return new ModConfigInfo()
|
|
{
|
|
Package = src,
|
|
Assemblies = GetAssembliesLegacy(src),
|
|
Configs = GetConfigsLegacy(src),
|
|
LuaScripts = GetLuaScriptsLegacy(src)
|
|
};
|
|
|
|
ImmutableArray<IAssemblyResourceInfo> GetAssembliesLegacy(ContentPackage srcPackage)
|
|
{
|
|
var binSearchInd = new (string SubFolder, Target Targets, Platform Platforms)[]
|
|
{
|
|
("bin/Client/Windows", Target.Client, Platform.Windows),
|
|
("bin/Client/Linux", Target.Client, Platform.Linux),
|
|
("bin/Client/OSX", Target.Client, Platform.OSX),
|
|
("bin/Server/Windows", Target.Server, Platform.Windows),
|
|
("bin/Server/Linux", Target.Server, Platform.Linux),
|
|
("bin/Server/OSX", Target.Server, Platform.OSX)
|
|
};
|
|
|
|
var builder = ImmutableArray.CreateBuilder<IAssemblyResourceInfo>();
|
|
|
|
foreach (var searchPathways in binSearchInd)
|
|
{
|
|
if (_storageService.FindFilesInPackage(srcPackage, searchPathways.SubFolder, "*.dll",
|
|
true) is { IsSuccess: true, Value.IsDefaultOrEmpty: false } result)
|
|
{
|
|
builder.Add(new AssemblyResourceInfo()
|
|
{
|
|
OwnerPackage = srcPackage,
|
|
InternalName = searchPathways.SubFolder,
|
|
SupportedPlatforms = searchPathways.Platforms,
|
|
SupportedTargets = searchPathways.Targets,
|
|
LoadPriority = 0,
|
|
FilePaths = result.Value.Select(fp => ContentPath.FromRaw(srcPackage, $"%ModDir%/{Path.GetRelativePath(srcPackage.Dir, fp)}".CleanUpPathCrossPlatform()))
|
|
.ToImmutableArray(),
|
|
FriendlyName = $"{srcPackage.Name}.{searchPathways.SubFolder.Replace('/','.')}",
|
|
IncompatiblePackages = ImmutableArray<Identifier>.Empty,
|
|
RequiredPackages = ImmutableArray<Identifier>.Empty,
|
|
IsScript = false,
|
|
IsReferenceModeOnly = false
|
|
});
|
|
}
|
|
}
|
|
|
|
var sharedResult = _storageService.FindFilesInPackage(srcPackage,
|
|
Path.Combine("CSharp/Shared"),
|
|
"*.cs", true);
|
|
var sharedFiles = sharedResult.IsSuccess && !sharedResult.Value.IsDefaultOrEmpty
|
|
? sharedResult.Value.Select(fp =>
|
|
ContentPath.FromRaw(srcPackage, $"%ModDir%/{Path.GetRelativePath(srcPackage.Dir, fp)}".CleanUpPathCrossPlatform()))
|
|
.ToImmutableArray()
|
|
: ImmutableArray<ContentPath>.Empty;
|
|
|
|
var srcSearchInd = new (string SubFolder, Target Targets, Platform Platforms)[]
|
|
{
|
|
("CSharp/Client", Target.Client, Platform.Any),
|
|
("CSharp/Server", Target.Server, Platform.Any)
|
|
};
|
|
|
|
foreach (var searchPathways in srcSearchInd)
|
|
{
|
|
// we have architecture dependent files as well
|
|
if (_storageService.FindFilesInPackage(srcPackage, searchPathways.SubFolder, "*.cs",
|
|
true) is { IsSuccess: true, Value.IsDefaultOrEmpty: false } result)
|
|
{
|
|
builder.Add(new AssemblyResourceInfo()
|
|
{
|
|
OwnerPackage = srcPackage,
|
|
InternalName = searchPathways.SubFolder,
|
|
SupportedPlatforms = searchPathways.Platforms,
|
|
SupportedTargets = searchPathways.Targets,
|
|
LoadPriority = 0,
|
|
FilePaths = result.Value
|
|
.Select(fp => ContentPath.FromRaw(srcPackage,
|
|
$"%ModDir%/{Path.GetRelativePath(srcPackage.Dir, fp)}".CleanUpPathCrossPlatform()))
|
|
.Concat(sharedFiles).ToImmutableArray(),
|
|
FriendlyName = IAssemblyLoaderService.InternalsAwareAssemblyName, // give the best chance of success (InternalsAware + Publicizer)
|
|
IncompatiblePackages = ImmutableArray<Identifier>.Empty,
|
|
RequiredPackages = ImmutableArray<Identifier>.Empty,
|
|
UseInternalAccessName = false, //compile as public and then fallback to internals
|
|
IsScript = true,
|
|
IsReferenceModeOnly = false
|
|
});
|
|
}
|
|
// add the shared files by themselves
|
|
else if (!sharedFiles.IsDefaultOrEmpty)
|
|
{
|
|
builder.Add(new AssemblyResourceInfo()
|
|
{
|
|
OwnerPackage = srcPackage,
|
|
InternalName = searchPathways.SubFolder,
|
|
SupportedPlatforms = searchPathways.Platforms,
|
|
SupportedTargets = searchPathways.Targets,
|
|
LoadPriority = 0,
|
|
FilePaths = sharedFiles,
|
|
FriendlyName = IAssemblyLoaderService.InternalsAwareAssemblyName,
|
|
IncompatiblePackages = ImmutableArray<Identifier>.Empty,
|
|
RequiredPackages = ImmutableArray<Identifier>.Empty,
|
|
UseInternalAccessName = true,
|
|
IsScript = true,
|
|
IsReferenceModeOnly = false
|
|
});
|
|
}
|
|
}
|
|
|
|
return builder.ToImmutable();
|
|
}
|
|
|
|
ImmutableArray<IConfigResourceInfo> GetConfigsLegacy(ContentPackage src)
|
|
{
|
|
return ImmutableArray<IConfigResourceInfo>.Empty;
|
|
}
|
|
|
|
ImmutableArray<ILuaScriptResourceInfo> GetLuaScriptsLegacy(ContentPackage src)
|
|
{
|
|
var builder = ImmutableArray.CreateBuilder<ILuaScriptResourceInfo>();
|
|
|
|
if (_storageService.FindFilesInPackage(src, "Lua", "*.lua", true)
|
|
is { IsSuccess: true, Value.IsDefaultOrEmpty: false } result)
|
|
{
|
|
ImmutableArray<string> cleanedResult = result.Value.Select(fp => fp.CleanUpPathCrossPlatform()).ToImmutableArray();
|
|
|
|
ImmutableArray<string> autorun = cleanedResult
|
|
.Where(fp => fp.Contains("Lua/ForcedAutorun/") || fp.Contains("Lua/Autorun/"))
|
|
.ToImmutableArray();
|
|
|
|
ImmutableArray<ContentPath> autorunFP = autorun.Select(fp => ContentPath.FromRaw(src,
|
|
$"%ModDir%/{Path.GetRelativePath(src.Dir, fp)}".CleanUpPathCrossPlatform()))
|
|
.ToImmutableArray();
|
|
|
|
ImmutableArray<ContentPath> reg = cleanedResult.Except(autorun)
|
|
.Select(fp => ContentPath.FromRaw(src,
|
|
$"%ModDir%/{Path.GetRelativePath(src.Dir, fp)}".CleanUpPathCrossPlatform()))
|
|
.ToImmutableArray();
|
|
|
|
builder.Add(new LuaScriptsResourceInfo()
|
|
{
|
|
OwnerPackage = src,
|
|
InternalName = "LegacyAutorun",
|
|
SupportedPlatforms = Platform.Any,
|
|
SupportedTargets = Target.Any,
|
|
LoadPriority = 1, // autorun should be last to ensure that dependent code in other files are loaded first
|
|
FilePaths = autorunFP,
|
|
IncompatiblePackages = ImmutableArray<Identifier>.Empty,
|
|
RequiredPackages = ImmutableArray<Identifier>.Empty,
|
|
IsAutorun = true,
|
|
RunUnrestricted = false
|
|
});
|
|
|
|
builder.Add(new LuaScriptsResourceInfo()
|
|
{
|
|
OwnerPackage = src,
|
|
InternalName = "Legacy",
|
|
SupportedPlatforms = Platform.Any,
|
|
SupportedTargets = Target.Any,
|
|
LoadPriority = 0, // should be included first to ensure that dependent code in these files are available
|
|
FilePaths = reg,
|
|
IncompatiblePackages = ImmutableArray<Identifier>.Empty,
|
|
RequiredPackages = ImmutableArray<Identifier>.Empty,
|
|
IsAutorun = false,
|
|
RunUnrestricted = false
|
|
});
|
|
}
|
|
|
|
return builder.ToImmutable();
|
|
}
|
|
|
|
}
|
|
}
|