Merge branch 'development'

Author: jhett12321

.env

@@ -1,2 +1,2 @@
 NWN_VERSION=8193.34
-NWNX_VERSION=d15bc22
+NWNX_VERSION=6a552d9

CHANGELOG.md

@@ -3,11 +3,28 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## 8193.34.6
+https://github.com/nwn-dotnet/Anvil/compare/v8193.34.5...v8193.34.6
+
+### Added
+- Added `Color` equality members `Equals` and operators `==` `!=`
+- `NwGameTables`: Added `ExpTable`
+- `NwGameTables`: Added `SkillItemCostTable`
+
+### Package Updates
+- Paket.Core 7.0.2 -> 7.1.4
+- NWNX d15bc22 -> 6a552d9
+
+### Fixed
+- Fixed an issue that prevented .NET 6 plugins from being loaded with Paket.
+
 ## 8193.34.5
 https://github.com/nwn-dotnet/Anvil/compare/v8193.34.4...v8193.34.5
 
 ### Added
 - `NwCreature.Encounter`: Gets the encounter that spawned the creature.
+- `NwAreaOfEffect.Spell`: Gets the spell that created the area of effect.
+- `NwAreaOfEffect.RemainingDuration`: Gets the remaining duration on the area of effect.
 
 ## 8193.34.4
 https://github.com/nwn-dotnet/Anvil/compare/v8193.34.3...v8193.34.4

NWN.Anvil.Tests/src/main/API/ColorTests.cs

@@ -8,15 +8,6 @@ namespace Anvil.Tests.API
   [TestFixture(Category = "API")]
   public sealed class ColorTests
   {
-    [Test]
-    [Description("Converts a color into a color token, then checks the resulting string for control characters.")]
-    [TestCaseSource(nameof(ColorTestCases))]
-    public void CreateColorTokenContainsNoNullTerminators(Color color)
-    {
-      string colorToken = color.ToColorToken();
-      Assert.That(colorToken, Does.Not.Contain('\0'), "color token contains a null character");
-    }
-
     [Test]
     [Description("Converting a color structure to a packed rgba value retains the correct color values.")]
     [TestCaseSource(nameof(ColorTestCases))]
@@ -40,13 +31,32 @@ public void ConvertColorToUnsignedRgbaRetainsValue(Color color)
     }
 
     [Test]
-    [Description("Converting a packed rgba value returns the correct color.")]
-    [TestCase(0xFF0000FFu, 0xFF, 0, 0, 0xFF)]
-    [TestCase(0x6E7882FFu, 0x6E, 0x78, 0x82, 0xFF)]
-    [TestCase(0x6E141E10u, 0x6E, 0x14, 0x1E, 0x10)]
-    public void ParseRGBAReturnsCorrectColor(uint packedColor, byte expectedRed, byte expectedGreen, byte expectedBlue, byte expectedAlpha)
+    [Description("Converts a color into a color token, then checks the resulting string for control characters.")]
+    [TestCaseSource(nameof(ColorTestCases))]
+    public void CreateColorTokenContainsNoNullTerminators(Color color)
     {
-      Assert.That(Color.FromRGBA(packedColor), Is.EqualTo(new Color(expectedRed, expectedGreen, expectedBlue, expectedAlpha)));
+      string colorToken = color.ToColorToken();
+      Assert.That(colorToken, Does.Not.Contain('\0'), "color token contains a null character");
+    }
+
+    [Test]
+    [Description("Deserializing a NUI color json structure creates the correct color.")]
+    [TestCase(@"{""r"":255,""g"":0,""b"":0,""a"":0}", 255, 0, 0, 0)]
+    [TestCase(@"{""r"":255,""g"":100,""b"":0,""a"":0}", 255, 100, 0, 0)]
+    [TestCase(@"{""r"":255,""g"":100,""b"":10,""a"":30}", 255, 100, 10, 30)]
+    public void DeserializeColorCreatesCorrectColor(string json, byte expectedRed, byte expectedGreen, byte expectedBlue, byte expectedAlpha)
+    {
+      Color color = JsonConvert.DeserializeObject<Color>(json);
+      Assert.That(color, Is.EqualTo(new Color(expectedRed, expectedGreen, expectedBlue, expectedAlpha)));
+    }
+
+    [Test]
+    [Description("Identical colors are considered equal.")]
+    [TestCaseSource(nameof(ColorTestCases))]
+    public void IdenticalColorsAreEqual(Color color)
+    {
+      Color color2 = new Color(color.Red, color.Green, color.Blue, color.Alpha);
+      Assert.AreEqual(color, color2);
     }
 
     [Test]
@@ -72,14 +82,13 @@ public void ParseRGBAHexStringReturnsCorrectColor(string hexString, byte expecte
     }
 
     [Test]
-    [Description("Deserializing a NUI color json structure creates the correct color.")]
-    [TestCase(@"{""r"":255,""g"":0,""b"":0,""a"":0}", 255, 0, 0, 0)]
-    [TestCase(@"{""r"":255,""g"":100,""b"":0,""a"":0}", 255, 100, 0, 0)]
-    [TestCase(@"{""r"":255,""g"":100,""b"":10,""a"":30}", 255, 100, 10, 30)]
-    public void DeserializeColorCreatesCorrectColor(string json, byte expectedRed, byte expectedGreen, byte expectedBlue, byte expectedAlpha)
+    [Description("Converting a packed rgba value returns the correct color.")]
+    [TestCase(0xFF0000FFu, 0xFF, 0, 0, 0xFF)]
+    [TestCase(0x6E7882FFu, 0x6E, 0x78, 0x82, 0xFF)]
+    [TestCase(0x6E141E10u, 0x6E, 0x14, 0x1E, 0x10)]
+    public void ParseRGBAReturnsCorrectColor(uint packedColor, byte expectedRed, byte expectedGreen, byte expectedBlue, byte expectedAlpha)
     {
-      Color color = JsonConvert.DeserializeObject<Color>(json);
-      Assert.That(color, Is.EqualTo(new Color(expectedRed, expectedGreen, expectedBlue, expectedAlpha)));
+      Assert.That(Color.FromRGBA(packedColor), Is.EqualTo(new Color(expectedRed, expectedGreen, expectedBlue, expectedAlpha)));
     }
 
     [Test]

NWN.Anvil.Tests/src/main/API/TwoDimArray/NwGameTableTests.cs

@@ -369,6 +369,7 @@ public void ProgrammedEffectTableReturnsValidData()
       Assert.That(lightRow.GetParamString(8), Is.EqualTo(null));
     }
 
+    [Test(Description = "Damage level table entries return valid data")]
     [TestCase(0, "UNINJURED", 6409)]
     [TestCase(1, "BARELY_INJURED", 6410)]
     [TestCase(2, "INJURED", 6411)]
@@ -379,8 +380,130 @@ public void DamageLevelTableReturnsValidData(int rowIndex, string label, int? st
       TwoDimArray<DamageLevelEntry> table = NwGameTables.DamageLevelTable;
       DamageLevelEntry row = table.GetRow(rowIndex);
 
+      Assert.That(row.RowIndex, Is.EqualTo(rowIndex));
       Assert.That(row.Label, Is.EqualTo(label));
       Assert.That(row.StrRef?.Id, Is.EqualTo(strRef));
     }
+
+    [Test(Description = "XP table entries return valid data")]
+    [TestCase(0, 1, 0u)]
+    [TestCase(1, 2, 1000u)]
+    [TestCase(2, 3, 3000u)]
+    [TestCase(3, 4, 6000u)]
+    [TestCase(4, 5, 10000u)]
+    [TestCase(5, 6, 15000u)]
+    [TestCase(6, 7, 21000u)]
+    [TestCase(7, 8, 28000u)]
+    [TestCase(8, 9, 36000u)]
+    [TestCase(9, 10, 45000u)]
+    [TestCase(10, 11, 55000u)]
+    [TestCase(11, 12, 66000u)]
+    [TestCase(12, 13, 78000u)]
+    [TestCase(13, 14, 91000u)]
+    [TestCase(14, 15, 105000u)]
+    [TestCase(15, 16, 120000u)]
+    [TestCase(16, 17, 136000u)]
+    [TestCase(17, 18, 153000u)]
+    [TestCase(18, 19, 171000u)]
+    [TestCase(19, 20, 190000u)]
+    [TestCase(20, 21, 210000u)]
+    [TestCase(21, 22, 231000u)]
+    [TestCase(22, 23, 253000u)]
+    [TestCase(23, 24, 276000u)]
+    [TestCase(24, 25, 300000u)]
+    [TestCase(25, 26, 325000u)]
+    [TestCase(26, 27, 351000u)]
+    [TestCase(27, 28, 378000u)]
+    [TestCase(28, 29, 406000u)]
+    [TestCase(29, 30, 435000u)]
+    [TestCase(30, 31, 465000u)]
+    [TestCase(31, 32, 496000u)]
+    [TestCase(32, 33, 528000u)]
+    [TestCase(33, 34, 561000u)]
+    [TestCase(34, 35, 595000u)]
+    [TestCase(35, 36, 630000u)]
+    [TestCase(36, 37, 666000u)]
+    [TestCase(37, 38, 703000u)]
+    [TestCase(38, 39, 741000u)]
+    [TestCase(39, 40, 780000u)]
+    [TestCase(40, 41, 0xFFFFFFFFu)]
+    public void ExpTableReturnsValidData(int rowIndex, int? level, uint? xp)
+    {
+      TwoDimArray<ExpTableEntry> table = NwGameTables.ExpTable;
+      ExpTableEntry row = table.GetRow(rowIndex);
+
+      Assert.That(row.RowIndex, Is.EqualTo(rowIndex));
+      Assert.That(row.Level, Is.EqualTo(level));
+      Assert.That(row.XP, Is.EqualTo(xp));
+    }
+
+    [Test(Description = "Skill item cost entries return valid data")]
+    [TestCase(0, 5, 1, 5, 10)]
+    [TestCase(1, 10, 1, 5, 10)]
+    [TestCase(2, 50, 1, 5, 10)]
+    [TestCase(3, 100, 1, 5, 10)]
+    [TestCase(4, 150, 1, 5, 10)]
+    [TestCase(5, 200, 1, 5, 10)]
+    [TestCase(6, 300, 1, 5, 10)]
+    [TestCase(7, 400, 1, 5, 10)]
+    [TestCase(8, 500, 1, 5, 10)]
+    [TestCase(9, 1000, 1, 5, 10)]
+    [TestCase(10, 2500, 5, 10, 15)]
+    [TestCase(11, 3750, 5, 10, 15)]
+    [TestCase(12, 4800, 5, 10, 15)]
+    [TestCase(13, 6500, 10, 15, 20)]
+    [TestCase(14, 9500, 10, 15, 20)]
+    [TestCase(15, 13000, 10, 15, 20)]
+    [TestCase(16, 17000, 10, 15, 20)]
+    [TestCase(17, 20000, 10, 15, 20)]
+    [TestCase(18, 30000, 15, 20, 25)]
+    [TestCase(19, 40000, 15, 20, 25)]
+    [TestCase(20, 50000, 15, 20, 25)]
+    [TestCase(21, 60000, 15, 20, 25)]
+    [TestCase(22, 80000, 15, 20, 25)]
+    [TestCase(23, 100000, 15, 20, 25)]
+    [TestCase(24, 150000, 20, 25, 30)]
+    [TestCase(25, 200000, 20, 25, 30)]
+    [TestCase(26, 250000, 20, 25, 30)]
+    [TestCase(27, 300000, 20, 25, 30)]
+    [TestCase(28, 350000, 25, 30, 35)]
+    [TestCase(29, 400000, 25, 30, 35)]
+    [TestCase(30, 500000, 25, 30, 35)]
+    [TestCase(31, 600000, 25, 30, 35)]
+    [TestCase(32, 700000, 30, 35, 40)]
+    [TestCase(33, 800000, 30, 35, 40)]
+    [TestCase(34, 900000, 30, 35, 40)]
+    [TestCase(35, 1000000, 30, 35, 40)]
+    [TestCase(36, 1100000, 35, 40, 45)]
+    [TestCase(37, 1200000, 35, 40, 45)]
+    [TestCase(38, 1300000, 35, 40, 45)]
+    [TestCase(39, 1400000, 35, 40, 45)]
+    [TestCase(40, 1500000, 40, 45, 50)]
+    [TestCase(41, 1600000, 40, 45, 50)]
+    [TestCase(42, 1700000, 40, 45, 50)]
+    [TestCase(43, 1800000, 40, 45, 50)]
+    [TestCase(44, 1900000, 45, 50, 55)]
+    [TestCase(45, 2000000, 45, 50, 55)]
+    [TestCase(46, 2100000, 45, 50, 55)]
+    [TestCase(47, 2200000, 45, 50, 55)]
+    [TestCase(48, 2300000, 50, 55, 60)]
+    [TestCase(49, 2400000, 50, 55, 60)]
+    [TestCase(50, 2500000, 50, 55, 60)]
+    [TestCase(51, 3000000, 55, 60, 65)]
+    [TestCase(52, 5000000, 60, 65, 70)]
+    [TestCase(53, 6000000, 70, 75, 80)]
+    [TestCase(54, 9000000, 80, 85, 90)]
+    [TestCase(55, 12000000, null, null, null)]
+    public void SkillItemCostTableReturnsValidData(int rowIndex, int? deviceCostMax, int? skillReqClass, int? skillReqRace, int? skillReqAlign)
+    {
+      TwoDimArray<SkillItemCostTableEntry> table = NwGameTables.SkillItemCostTable;
+      SkillItemCostTableEntry row = table.GetRow(rowIndex);
+
+      Assert.That(row.RowIndex, Is.EqualTo(rowIndex));
+      Assert.That(row.DeviceCostMax, Is.EqualTo(deviceCostMax));
+      Assert.That(row.ClassSkillRequirement, Is.EqualTo(skillReqClass));
+      Assert.That(row.RaceSkillRequirement, Is.EqualTo(skillReqRace));
+      Assert.That(row.AlignmentSkillRequirement, Is.EqualTo(skillReqAlign));
+    }
   }
 }

NWN.Anvil/NWN.Anvil.csproj

@@ -1,6 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <!--Build-->
   <PropertyGroup>
+    <!--When changing target frameworks, make sure to update Anvil.Internal.Assemblies.TargetFrameworks-->
     <TargetFrameworks>net5.0;net6.0</TargetFrameworks>
     <RuntimeIdentifier>linux-x64</RuntimeIdentifier>
     <SatelliteResourceLanguages>en</SatelliteResourceLanguages>
@@ -58,7 +59,7 @@
     <PackageReference Include="LightInject" Version="6.4.1" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     <PackageReference Include="NLog" Version="4.7.15" />
-    <PackageReference Include="Paket.Core" Version="7.0.2" PrivateAssets="all" />
+    <PackageReference Include="Paket.Core" Version="7.1.4" PrivateAssets="all" />
     <PackageReference Include="NWN.Core" Version="8193.34.3" PrivateAssets="compile" />
     <PackageReference Include="NWN.Native" Version="8193.34.3" PrivateAssets="compile" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="all" />

NWN.Anvil/src/main/API/Color.cs

@@ -7,7 +7,7 @@ namespace Anvil.API
   /// <summary>
   /// A 8 bit Color structure.
   /// </summary>
-  public readonly struct Color
+  public readonly struct Color : IEquatable<Color>
   {
     /// <summary>
     /// Gets the alpha value of this color as a byte (0-255).
@@ -120,6 +120,31 @@ public static Color FromRGBA(string rgbaHexString)
       return FromRGBA(Convert.ToInt32(rgbaHexString.Trim().TrimStart('#'), 16));
     }
 
+    public static bool operator ==(Color left, Color right)
+    {
+      return left.Equals(right);
+    }
+
+    public static bool operator !=(Color left, Color right)
+    {
+      return !left.Equals(right);
+    }
+
+    public bool Equals(Color other)
+    {
+      return Alpha == other.Alpha && Blue == other.Blue && Green == other.Green && Red == other.Red;
+    }
+
+    public override bool Equals(object obj)
+    {
+      return obj is Color other && Equals(other);
+    }
+
+    public override int GetHashCode()
+    {
+      return HashCode.Combine(Alpha, Blue, Green, Red);
+    }
+
     /// <summary>
     /// Returns the 3 character sequence token for this color, used in coloring text.<br/>
     /// This is mostly for internal use. Use <see cref="StringExtensions.ColorString"/> for formatting text with a certain color.

NWN.Anvil/src/main/API/Object/NwAreaOfEffect.cs

@@ -18,6 +18,16 @@ internal NwAreaOfEffect(CNWSAreaOfEffectObject areaOfEffectObject) : base(areaOf
       AreaOfEffect = areaOfEffectObject;
     }
 
+    /// <summary>
+    /// Gets the spell from which the Area Of Effect was created.
+    /// </summary>
+    public NwSpell Spell => NwSpell.FromSpellId((int)AreaOfEffect.m_nSpellId);
+
+    /// <summary>
+    /// Gets the Area Of Effect duration.
+    /// </summary>
+    public TimeSpan RemainingDuration => TimeSpan.FromMilliseconds(AreaOfEffect.m_nDuration);
+
     /// <summary>
     /// Gets the creator of this Area of Effect.
     /// </summary>

NWN.Anvil/src/main/API/TwoDimArray/Tables/ExpTableEntry.cs

@@ -0,0 +1,23 @@
+namespace Anvil.API
+{
+  public sealed class ExpTableEntry : ITwoDimArrayEntry
+  {
+    /// <summary>
+    /// Gets the character level.
+    /// </summary>
+    public int? Level { get; set; }
+
+    public int RowIndex { get; init; }
+
+    /// <summary>
+    /// Gets the XP required to gain <see cref="Level"/>.
+    /// </summary>
+    public uint? XP { get; set; }
+
+    public void InterpretEntry(TwoDimArrayEntry entry)
+    {
+      Level = entry.GetInt("Level");
+      XP = unchecked((uint?)entry.GetInt("XP"));
+    }
+  }
+}

NWN.Anvil/src/main/API/TwoDimArray/Tables/ExpTableExtensions.cs

@@ -0,0 +1,38 @@
+using System.Linq;
+
+namespace Anvil.API
+{
+  public static class ExpTableExtensions
+  {
+    /// <summary>
+    /// Gets the current level for a player with the specified XP.
+    /// </summary>
+    /// <param name="table">The table to lookup.</param>
+    /// <param name="xp">The amount of xp.</param>
+    public static int? GetLevelFromXP(this TwoDimArray<ExpTableEntry> table, int xp)
+    {
+      int? level = 1;
+      foreach (ExpTableEntry entry in table)
+      {
+        if (entry.XP > xp)
+        {
+          break;
+        }
+
+        level = entry.Level;
+      }
+
+      return level;
+    }
+
+    /// <summary>
+    /// Gets the amount of XP needed for the specified level.
+    /// </summary>
+    /// <param name="table">The table to lookup.</param>
+    /// <param name="level">The level to lookup.</param>
+    public static uint? GetXPFromLevel(this TwoDimArray<ExpTableEntry> table, int level)
+    {
+      return table.FirstOrDefault(entry => entry.Level == level)?.XP;
+    }
+  }
+}