- More work on package loading.

- Implementing equality comparison for package dependencies.

Author: TBN-MapleWheels

Barotrauma/BarotraumaShared/SharedSource/LuaCs/Data/DataInterfaceDefinitions.cs

@@ -51,6 +51,59 @@ public record DependencyInfo : IPackageDependencyInfo
     public ulong SteamWorkshopId { get; init; }
     public ContentPackage DependencyPackage { get; init; }
     public bool IsMissing { get; init; }
+    public bool IsWorkshopInstallation { get; init; }
+
+    public virtual bool Equals(DependencyInfo other) => Equals(this, other);
+
+    public override int GetHashCode()
+    {
+        if (DependencyPackage is not null)
+            return DependencyPackage.GetHashCode();
+        if (SteamWorkshopId != 0)
+            return SteamWorkshopId.GetHashCode();
+        if (!PackageName.IsNullOrWhiteSpace() && !FolderPath.IsNullOrWhiteSpace())
+            return string.Concat(PackageName, FolderPath).GetHashCode();
+        if (!InternalName.IsNullOrWhiteSpace() && !FolderPath.IsNullOrWhiteSpace())
+            return string.Concat(InternalName, FolderPath).GetHashCode();
+        
+        return base.GetHashCode();
+    }
+
+    public bool Equals(IPackageDependencyInfo x, IPackageDependencyInfo y)
+    {
+        if (x is null)
+            return false;
+        if (y is null)
+            return false;
+        if (x == y)
+            return true;
+        
+        if (x.DependencyPackage is not null && y.DependencyPackage is not null)
+            return y.DependencyPackage == x.DependencyPackage;
+        
+        if (!x.FolderPath.IsNullOrWhiteSpace()
+            && !y.FolderPath.IsNullOrWhiteSpace()
+            && y.FolderPath == x.FolderPath)
+            return true;
+        
+        if (!x.FolderPath.IsNullOrWhiteSpace() != !y.FolderPath.IsNullOrWhiteSpace()) 
+            return false;
+        
+        if (!x.PackageName.IsNullOrWhiteSpace() 
+            && !y.PackageName.IsNullOrWhiteSpace() 
+            && y.PackageName == x.PackageName)
+            return true;
+        
+        if (x.SteamWorkshopId != 0 && y.SteamWorkshopId == x.SteamWorkshopId)
+            return true;
+
+        return false;
+    }
+
+    public int GetHashCode(IPackageDependencyInfo obj)
+    {
+        throw new NotImplementedException();
+    }
 }
 
 public record LocalizationResourceInfo : ILocalizationResourceInfo

Barotrauma/BarotraumaShared/SharedSource/LuaCs/Data/IPackageDependencyInfo.cs

@@ -1,8 +1,11 @@
-using System.Collections.Immutable;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Immutable;
 
 namespace Barotrauma.LuaCs.Data;
 
-public interface IPackageDependencyInfo : IPackageInfo
+public interface IPackageDependencyInfo : IPackageInfo, 
+    IEqualityComparer<IPackageDependencyInfo>
 {
     /// <summary>
     /// Root folder of the content package.
@@ -25,6 +28,11 @@ public interface IPackageDependencyInfo : IPackageInfo
     /// This dependency was not found.
     /// </summary>
     public bool IsMissing { get; }
+    
+    /// <summary>
+    /// Whether the package is installed from the workshop. False means installation is from local mods.
+    /// </summary>
+    public bool IsWorkshopInstallation { get; }
 }
 
 public interface IPackageDependenciesInfo

Barotrauma/BarotraumaShared/SharedSource/LuaCs/Services/IPackageManagementService.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using Barotrauma.Extensions;
 using Barotrauma.LuaCs.Data;
@@ -27,7 +28,7 @@ public interface IPackageManagementService : IService
     FluentResults.Result UnloadPackages();
     bool IsPackageLoaded(ContentPackage package);
     bool CheckDependencyLoaded(IPackageDependencyInfo info);
-    bool CheckDependenciesLoaded(IEnumerable<IPackageDependencyInfo> infos, out IReadOnlyList<IPackageDependencyInfo> missingPackages);
+    bool CheckDependenciesLoaded([NotNull]IEnumerable<IPackageDependencyInfo> infos, out ImmutableArray<IPackageDependencyInfo> missingPackages);
     bool CheckEnvironmentSupported(IPlatformInfo platform);
 }
 

Barotrauma/BarotraumaShared/SharedSource/LuaCs/Services/PackageManagementService.cs

@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Threading;
@@ -165,6 +166,8 @@ public FluentResults.Result ProcessQueuedPackages(bool rescanPackages = false, b
             /*
              * Helper functions
              */
+            
+            // register in the list so we can check against it.
             FluentResults.Result LoadPackageInfo(LoadablePackage package)
             {
                 try
@@ -199,18 +202,42 @@ FluentResults.Result LoadPackageInfo(LoadablePackage package)
             }
 
             /*
-             * Return array: (Normal, MissingDeps)
+             * Return array: (Normal, MissingDepsRes, MissingDeps)
              */
-            FluentResults.Result<(ImmutableArray<T>, ImmutableArray<T>)> GetLoadablePackages<T>(ImmutableArray<T> resources, bool errorForPacksMissingDeps = false)
+            FluentResults.Result<(ImmutableArray<T>, ImmutableArray<T>, ImmutableArray<IPackageDependencyInfo>)> GetLoadablePackages<T>(ImmutableArray<T> resources, bool errorForPacksMissingDeps = false)
                 where T : class, IPackageDependenciesInfo, IPackageInfo, IResourceInfo, IResourceCultureInfo
             {
-                throw new NotImplementedException();
 
                 // filter optional resources (process later)
                 // add back in optional packages that are required by other required packages
                 // filter and log required packages that are missing dependencies
                 // re-include optionals where dependencies are available
                 // return both lists (A normal, B missingDeps).
+
+                HashSet<IPackageDependencyInfo> missingDeps = new();
+                var missingDepsBuilder = ImmutableArray.CreateBuilder<T>();
+                
+                var reqPacks = resources.Where(r => !r.Optional).Select(r => r.OwnerPackage).Distinct().ToImmutableHashSet();
+                var optPack = resources.Where(r => r.Optional).Select(r => r.OwnerPackage).Distinct().ToImmutableHashSet();
+                var req = resources
+                    .Where(r => !r.Optional)
+                    .Where(CheckEnvironmentSupported)
+                    .Where(r =>
+                    {
+                        if (r.Dependencies.Length == 0)
+                            return true;
+
+                        if (CheckDependenciesLoaded(r.Dependencies, out var missingDepsList)) 
+                            return true;
+                        
+                        missingDepsBuilder.Add(r);
+                        missingDeps.UnionWith(missingDepsList);
+                        return false;
+                    });
+                var reqOptionals = resources.Where(r => r.Optional && optPack.Contains(r.OwnerPackage));
+                var notReqOptionals = resources.Where(r => r.Optional && !optPack.Contains(r.OwnerPackage));
+                
+                throw new NotImplementedException();
             }
 
             FluentResults.Result<ImmutableArray<T>> SortByDependencies<T>(ImmutableArray<T> resources)
@@ -235,7 +262,11 @@ FluentResults.Result<ImmutableArray<T>> SortByDependencies<T>(ImmutableArray<T>
     public FluentResults.Result UnloadPackages()
     {
         if (!ModUtils.Environment.IsMainThread)
-            throw new InvalidOperationException($"{nameof(UnloadPackages)}: This method can only be called on the main thread.");
+        {
+            return FluentResults.Result.Fail(
+                new ExceptionalError(new InvalidOperationException($"{nameof(UnloadPackages)}: This method can only be called on the main thread."))
+                    .WithMetadata(MetadataType.ExceptionObject, this));
+        }
 
         var res = new FluentResults.Result();
         _contentPackagesModificationsLock.EnterWriteLock();
@@ -256,16 +287,15 @@ public FluentResults.Result UnloadPackages()
     public bool CheckDependencyLoaded(IPackageDependencyInfo info) =>
         info is not null && IsPackageLoaded(info.DependencyPackage);
 
-    public bool CheckDependenciesLoaded(IEnumerable<IPackageDependencyInfo> infos, out IReadOnlyList<IPackageDependencyInfo> missingPackages)
+    public bool CheckDependenciesLoaded([NotNull]IEnumerable<IPackageDependencyInfo> infos, out ImmutableArray<IPackageDependencyInfo> missingPackages)
     {
-        var missing = new List<IPackageDependencyInfo>();
-        foreach (IPackageDependencyInfo info in infos)
-        {
-            if (!CheckDependencyLoaded(info))
-                missing.Add(info);
-        }
-        missingPackages = missing;
-        return missing.Count == 0;
+        var missing = ImmutableArray.CreateBuilder<IPackageDependencyInfo>();
+        missing.AddRange(infos
+            .Where(i => i.DependencyPackage is not null)
+            .DistinctBy(i => i.DependencyPackage)
+            .Where(i => !CheckDependencyLoaded(i)));
+        missingPackages = missing.MoveToImmutable();
+        return missingPackages.Length == 0;
     }
 
     public bool CheckEnvironmentSupported(IPlatformInfo platform)

Barotrauma/BarotraumaShared/SharedSource/LuaCs/Services/PackageService.cs

@@ -644,11 +644,12 @@ private FluentResults.Result SanitationChecksEnumerable<T>(ImmutableArray<T> res
 
             if (resourceInfo.Dependencies.IsDefaultOrEmpty)
                 continue;
-            
-            resourceInfo.Dependencies.ForEach(pdi =>
+
+            // ReSharper disable once ForeachCanBePartlyConvertedToQueryUsingAnotherGetEnumerator
+            foreach (var pdi in resourceInfo.Dependencies)
             {
-                // for clarification: assemblies passed to the function should always be loaded.
-                // optional assemblies should be filtered out before the list is sent.
+                // for clarification: all resources passed to the function should always be loaded.
+                // unneeded optional resources should be filtered out before the list is sent.
                 // left this as a reminder :)
                 /*if (pdi.Optional)
                     return;*/
@@ -659,7 +660,7 @@ private FluentResults.Result SanitationChecksEnumerable<T>(ImmutableArray<T> res
                         .WithMetadata(MetadataType.ExceptionObject, this)
                         .WithMetadata(MetadataType.RootObject, resourceInfo));
                 }
-            });
+            }
 
             // check runtime platform
             if (!_packageManagementService.CheckEnvironmentSupported(resourceInfo))