vlad.os/LuaCsForBarotraumaEP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

- Fixed resource data not returning into the correct context.

Browse Source
This commit is contained in:
Maplewheels
2026-01-25 14:50:29 -05:00
parent 8dc58445f9
commit d0f5cb87e7
2 changed files with 50 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
Barotrauma/BarotraumaShared/SharedSource/LuaCs/Services/Processing/ModConfigFileParserService.cs
View File

@@ -53,14 +53,14 @@ public sealed class ModConfigFileParserService :
// --- Assemblies
async Task<Result<IAssemblyResourceInfo>> IParserServiceAsync<ResourceParserInfo, IAssemblyResourceInfo>.TryParseResourceAsync(ResourceParserInfo src)
{
using var lck = await _operationsLock.AcquireWriterLock();
using var lck = await _operationsLock.AcquireReaderLock();
IService.CheckDisposed(this);
if (CheckThrowNullRefs(src, "Assembly") is { IsFailed: true } fail)
return fail;
var runtimeEnv = GetRuntimeEnvironment(src.Element);
var fileResults = await GetCheckedFiles(src.Element, src.Owner, ".dll");
var fileResults = await UnsafeGetCheckedFiles(src.Element, src.Owner, ".dll");
if (fileResults.IsFailed)
return FluentResults.Result.Fail(fileResults.Errors);
@@ -91,15 +91,14 @@ public sealed class ModConfigFileParserService :
async Task<Result<IConfigResourceInfo>> IParserServiceAsync<ResourceParserInfo, IConfigResourceInfo>.TryParseResourceAsync(ResourceParserInfo src)
{
using var lck = await _operationsLock.AcquireWriterLock();
using var lck = await _operationsLock.AcquireReaderLock();
IService.CheckDisposed(this);
if (CheckThrowNullRefs(src, "Config") is { IsFailed: true } fail)
return fail;
var runtimeEnv = GetRuntimeEnvironment(src.Element);
var fileResults = await GetCheckedFiles(src.Element, src.Owner, ".xml");
var fileResults = await UnsafeGetCheckedFiles(src.Element, src.Owner, ".xml");
if (fileResults.IsFailed)
return FluentResults.Result.Fail(fileResults.Errors);
@@ -126,14 +125,14 @@ public sealed class ModConfigFileParserService :
// --- Lua Scripts
async Task<Result<ILuaScriptResourceInfo>> IParserServiceAsync<ResourceParserInfo, ILuaScriptResourceInfo>.TryParseResourceAsync(ResourceParserInfo src)
{
using var lck = await _operationsLock.AcquireWriterLock();
using var lck = await _operationsLock.AcquireReaderLock();
IService.CheckDisposed(this);
if (CheckThrowNullRefs(src, "Lua") is { IsFailed: true } fail)
return fail;
var runtimeEnv = GetRuntimeEnvironment(src.Element);
var fileResults = await GetCheckedFiles(src.Element, src.Owner, ".lua");
var fileResults = await UnsafeGetCheckedFiles(src.Element, src.Owner, ".lua");
if (fileResults.IsFailed)
return FluentResults.Result.Fail(fileResults.Errors);
@@ -174,34 +173,39 @@ public sealed class ModConfigFileParserService :
}
// --- Helpers
private async Task<Result<ImmutableArray<ContentPath>>> GetCheckedFiles(XElement srcElement, ContentPackage srcOwner, string fileExtension)
private async Task<Result<ImmutableArray<ContentPath>>> UnsafeGetCheckedFiles(XElement srcElement, ContentPackage srcOwner, string fileExtension)
{
using var lck = await _operationsLock.AcquireWriterLock();
IService.CheckDisposed(this);
var builder = ImmutableArray.CreateBuilder<ContentPath>();
var filePath = srcElement.GetAttributeString("File", string.Empty);
var folderPath = srcElement.GetAttributeString("Folder", string.Empty);
var filePath = srcElement.GetAttributeContentPath("File", srcOwner);
var folderPath = srcElement.GetAttributeContentPath("Folder", srcOwner);
var res = new FluentResults.Result<ImmutableArray<ContentPath>>();
if (!filePath.IsNullOrWhiteSpace())
{
var cp = ContentPath.FromRaw(srcOwner, filePath);
if (_storageService.FileExists(cp.FullPath) is { IsSuccess: true, Value: true })
if (_storageService.FileExists(filePath.FullPath) is { IsSuccess: true, Value: true })
{
builder.Add(cp);
builder.Add(filePath);
}
else
{
res.WithError($"{srcOwner.Name}: The file '{filePath}' is missing!");
}
}
if (!folderPath.IsNullOrWhiteSpace())
{
var cp = ContentPath.FromRaw(srcOwner, folderPath);
if (_storageService.DirectoryExists(cp.FullPath) is { IsSuccess: true, Value: true })
if (_storageService.DirectoryExists(folderPath.FullPath) is { IsSuccess: true, Value: true })
{
var files = _storageService.FindFilesInPackage(cp.ContentPackage, cp.Value, fileExtension, true);
var files = _storageService.FindFilesInPackage(srcOwner, folderPath.Value, fileExtension, true);
}
else
{
res.WithError($"{srcOwner.Name}: The folder '{filePath}' is missing!");
}
}
throw new NotImplementedException();
return res.WithValue(builder.ToImmutable());
}
private (Platform Platform, Target Target) GetRuntimeEnvironment(XElement element)
{

64
Barotrauma/BarotraumaShared/SharedSource/LuaCs/Services/Processing/ModConfigService.cs
View File

@@ -95,16 +95,26 @@ public sealed class ModConfigService : IModConfigService
ThrowHelper.ThrowArgumentNullException($"{nameof(CreateConfigsAsync)}: The supplied array is default or empty!");
using var lck = await _operationsLock.AcquireReaderLock();
IService.CheckDisposed(this);
var builder = new ConcurrentQueue<(ContentPackage Source, Result<IModConfigInfo> Config)>();
await src.ParallelForEachAsync(async package =>
var builder = ImmutableArray.CreateBuilder<Task<Task<Result<IModConfigInfo>>>>(src.Length);
foreach (var srcItem in src)
{
var res = await CreateConfigAsync(package);
builder.Enqueue((package, res));
});
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}");
}
return builder.OrderBy(pkg => src.IndexOf(pkg.Source)).ToImmutableArray();
var r = await taskResult;
returnResults.Add((r.Value.Package, r));
}
return returnResults.ToImmutable();
}
//--- Helpers
@@ -117,42 +127,18 @@ public sealed class ModConfigService : IModConfigService
private async Task<Result<IModConfigInfo>> CreateFromConfigXmlAsync(ContentPackage owner, XElement src)
{
ImmutableArray<IAssemblyResourceInfo> assemblyResources = default;
ImmutableArray<IConfigResourceInfo> configResources = default;
ImmutableArray<ILuaScriptResourceInfo> luaResources = default;
var tasks = new[]
{
new Task<Task>(async () => assemblyResources = await GetAssembliesFromXml(owner, src)),
new Task<Task>(async () => configResources = await GetConfigsFromXml(owner, src)),
new Task<Task>(async () => luaResources = await GetLuaScriptsFromXml(owner, src)),
};
tasks.ForEach(t => t.Start());
var res = await Task.WhenAll(tasks);
bool isFaulted = false;
foreach (var task in res)
{
if (task.IsFaulted)
{
_logger.LogError($"{nameof(CreateFromConfigXmlAsync)}: {task.Exception?.ToString()}");
isFaulted = true;
}
}
if (isFaulted)
{
_logger.LogError($"{nameof(CreateFromConfigXmlAsync)}: Failed to process content package: {owner.Name}");
return FluentResults.Result.Fail($"{nameof(CreateFromConfigXmlAsync)}: Failed to process content package: {owner.Name}");
}
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));
await Task.WhenAll(asmTask, cfgTask, luaTask);
return FluentResults.Result.Ok<IModConfigInfo>(new ModConfigInfo()
{
Package = owner,
Assemblies = assemblyResources,
Configs = configResources,
LuaScripts = luaResources
Assemblies = await await asmTask,
Configs = await await cfgTask,
LuaScripts = await await luaTask
});
async Task<ImmutableArray<ILuaScriptResourceInfo>> GetLuaScriptsFromXml(ContentPackage contentPackage,