Feature/dotnet 10

.github/workflows/build-and-test.yml

@@ -2,7 +2,7 @@ name: Build And Test
 on: [push]
 
 env:
-  BuildVersion: '0.43.${{github.run_number}}'
+  BuildVersion: '0.44.${{github.run_number}}'
   SolutionFile: 'src/OpenRpg.sln'
   DemoProject: 'src/OpenRpg.Demos.Web/OpenRpg.Demos.Web.csproj'
   EditorProject: 'src/OpenRpg.Editor/OpenRpg.Editor.csproj'
@@ -14,10 +14,10 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      - name: Setup .NET 9.0
+      - name: Setup .NET 10.0
         uses: actions/setup-dotnet@v2
         with:
-          dotnet-version: 9.0.x
+          dotnet-version: 10.0.x
 
       - name: .Net Restore
         run: dotnet restore ${{ env.SolutionFile }}
@@ -63,10 +63,10 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      - name: Setup .NET 9.0
+      - name: Setup .NET 10.0
         uses: actions/setup-dotnet@v2
         with:
-          dotnet-version: 9.0.x
+          dotnet-version: 10.0.x
 
       - name: Build Web Demo
         run: dotnet publish -c Release -o demo "${{ env.DemoProject }}"
@@ -95,10 +95,10 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      - name: Setup .NET 9.0
+      - name: Setup .NET 10.0
         uses: actions/setup-dotnet@v2
         with:
-          dotnet-version: 9.0.x
+          dotnet-version: 10.0.x
 
       - name: Build Editor App
         run: dotnet publish -c Release -r win-x64 --sc /p:Version=${{ env.BuildVersion }} -o /editor "${{ env.EditorProject }}"

build/pack.bat

@@ -1,4 +1,4 @@
-set version=0.29.00
+set version=0.43.00
 dotnet pack ../src/OpenRpg.Core -c Release -o ../../_dist /p:version=%version%
 dotnet pack ../src/OpenRpg.Items -c Release -o ../../_dist /p:version=%version%
 dotnet pack ../src/OpenRpg.Combat -c Release -o ../../_dist /p:version=%version%
@@ -11,4 +11,5 @@ dotnet pack ../src/OpenRpg.Genres.Fantasy -c Release -o ../../_dist /p:version=%
 dotnet pack ../src/OpenRpg.Cards -c Release -o ../../_dist /p:version=%version%
 dotnet pack ../src/OpenRpg.CurveFunctions -c Release -o ../../_dist /p:version=%version%
 dotnet pack ../src/OpenRpg.Tags -c Release -o ../../_dist /p:version=%version%
-dotnet pack ../src/OpenRpg.Items.TradeSkills -c Release -o ../../_dist /p:version=%version%
+dotnet pack ../src/OpenRpg.Items.TradeSkills -c Release -o ../../_dist /p:version=%version%
+dotnet pack ../src/OpenRpg.AdviceEngine.Rx -c Release -o ../../_dist /p:version=%version%

docs/quests.md

@@ -2,6 +2,118 @@
 
 The quests project builds upon the `OpenRpg.Items` project to allow a way to express quests that can be carried out by players within the game.
 
-A `Quest` is a `Template` that generally contains information about the `Objective`, the `Rewards` as well as other metadata as well as a way to track the state of completed quests and faction information.
+A `QuestTemplate` is a `Template` that generally contains information about the `Objectives`, the `Rewards` as well as other metadata and a way to track the state of completed quests and faction information.
 
-> It is recommended you look over the interactive web demo for a more in depth example and explanation of this project.
+> It is recommended you look over the interactive web demo for a more in depth example and explanation of this project.
+
+## Quest Structure
+
+```csharp
+var quest = new QuestTemplate
+{
+    Id = 1,
+    NameLocaleId = "Goblin Hunt",
+    DescriptionLocaleId = "Defeat 3 goblins terrorising the village.",
+    IsRepeatable = false,
+    Objectives = new List<Objective> { ... },
+    Rewards = new List<Reward> { ... },
+    Gifts = new List<Reward> { ... },           // items given at quest start
+    Variables = new QuestTemplateVariables()             // stores Requirements at key 4003
+};
+```
+
+### Objectives
+
+Each `Objective` has an `ObjectiveType` (int) and an `Association` (AssociatedId + AssociatedValue).
+
+| Type | Constant | Meaning |
+|------|----------|---------|
+| 1 | `TriggerObjective` | A trigger must be set |
+| 2 | `ItemObjective` | Collect N items (AssociatedId = item template id, AssociatedValue = count) |
+| 3 | `LevelObjective` | Reach a level (AssociatedValue = required level) |
+| 4 | `ClassObjective` | Have a class (AssociatedId = class template id) |
+| 5 | `EffectObjective` | Have an active effect (AssociatedId = effect id) |
+| 6 | `QuestObjective` | Complete another quest (AssociatedId = quest id) |
+| 30 | `CurrencyObjective` | Collect N currency (AssociatedValue = amount) |
+| 31 | `EnemyDefeatedObjective` | Defeat N enemies (AssociatedId = enemy id, AssociatedValue = count) |
+| 32 | `EnemySightedObjective` | Sight N enemies (AssociatedId = enemy id, AssociatedValue = count) |
+
+### Rewards
+
+Rewards have a `RewardType`, `RewardChance`, and `Association`. Common types include experience, currency, and item rewards.
+
+### Requirements
+
+Requirements live on `quest.Variables.Requirements` (key 4003) and gate quest acceptance. They are checked via `ICharacterRequirementChecker`.
+
+## Objective Verification
+
+The `ICharacterObjectiveChecker` follows the same pattern as `ICharacterRequirementChecker` — it has four overloads for different contexts:
+
+```csharp
+public interface ICharacterObjectiveChecker : IObjectiveChecker<Character>
+{
+    // Stateless checks — verified from live character state
+    bool IsObjectiveMet(Character character, Objective objective);         // level, class, effects
+    bool IsObjectiveMet(IQuestState state, Objective objective);          // quest prerequisites
+    bool IsObjectiveMet(ITriggerState state, Objective objective);        // trigger objectives
+
+    // Stateful checks — verified from accumulated progress
+    bool IsObjectiveMet(IObjectiveState state, Objective objective, int questId, int objectiveIndex);
+}
+```
+
+**Stateless objectives** (trigger, quest, level, class, effect) are checked against live game state each time.
+
+**Stateful objectives** (items, kills, currency) compare accumulated progress against the required threshold.
+
+### Batch Checking
+
+```csharp
+// Check all objectives for a quest across all four contexts
+var allMet = ObjectiveChecker.AreObjectivesMet(character, questData);
+```
+
+## Objective State Tracking
+
+`IObjectiveState` stores per-quest-per-objective progress as a dictionary of composite keys to int counts.
+
+The composite key combines `questId` and `objectiveIndex` into a single int: `(questId << 16) | objectiveIndex`.
+
+```csharp
+// Access via entity variables (optional — can also use standalone)
+character.Variables.ObjectiveState.GetObjectiveProgress(questId, objectiveIndex);
+character.Variables.ObjectiveState.AddObjectiveProgress(questId, objectiveIndex, 1);
+character.Variables.ObjectiveState.IsObjectiveComplete(questId, objectiveIndex, requiredAmount);
+character.Variables.ObjectiveState.ClearQuestObjectives(questId, quest.Objectives.Count);
+```
+
+Progress is **push-based** — game code explicitly calls `AddObjectiveProgress` when events happen (enemy killed, item collected, etc.).
+
+## QuestData
+
+`QuestData` is a proper `ITemplateData` instance that bundles quest definition, state, and objective state. It links to the template via `TemplateId` (like `ItemData`):
+
+```csharp
+var questData = new QuestData(quest.Id, QuestStateTypes.QuestActive);
+// questData.TemplateId    — links to the QuestTemplate
+// questData.State         — current state (NotStarted/Active/Complete)
+// questData.ObjectiveState — per-objective progress
+```
+
+## Typical Usage
+
+```csharp
+// Accept a quest
+var questData = new QuestData(quest.Id, QuestStateTypes.QuestActive);
+questData.ObjectiveState.ClearQuestObjectives(quest.Id, quest.Objectives.Count);
+
+// Track progress (called by game code when events happen)
+questData.ObjectiveState.AddObjectiveProgress(quest.Id, objectiveIndex, 1);
+
+// Check if all objectives are met
+var canComplete = ObjectiveChecker.AreObjectivesMet(character, quest, questData);
+
+// Complete the quest
+questData.State = QuestStateTypes.QuestComplete;
+```

src/OpenRpg.AdviceEngine.Rx/OpenRpg.AdviceEngine.Rx.csproj

@@ -8,16 +8,16 @@
         <PackageProjectUrl>https://github.com/openrpg/OpenRpg</PackageProjectUrl>
         <Description>A Utility AI flavoured framework to provide advice about what entities should do</Description>
         <PackageTags>rpg game-development xna monogame unity godot rx</PackageTags>
-        <TargetFramework>netstandard2.1</TargetFramework>
-        <LangVersion>8</LangVersion>
+        <TargetFramework>net10.0</TargetFramework>
+        <LangVersion>14</LangVersion>
     </PropertyGroup>
 
     <ItemGroup>
       <ProjectReference Include="..\OpenRpg.AdviceEngine\OpenRpg.AdviceEngine.csproj" />
     </ItemGroup>
 
     <ItemGroup>
-      <PackageReference Include="System.Reactive" Version="6.0.1" />
+      <PackageReference Include="System.Reactive" Version="6.1.0" />
     </ItemGroup>
 
 </Project>

src/OpenRpg.AdviceEngine/Applicators/IApplicator.cs

@@ -1,12 +1,13 @@
+using System.Collections.Generic;
 using OpenRpg.Core.Requirements;
-using OpenRpg.Entities.Requirements;
 
 namespace OpenRpg.AdviceEngine.Applicators
 {
-    public interface IApplicator : IHasRequirements
+    public interface IApplicator
     {
         int Priority { get; }
         bool CanApplyTo(IAgent agent);
         void ApplyTo(IAgent agent);
+        IReadOnlyCollection<Requirement> Requirements { get; }
     }
 }

src/OpenRpg.AdviceEngine/Extensions/UtilityExtensions.cs

@@ -8,24 +8,14 @@ public static class UtilityExtensions
     {
         public static float CalculateScore(this IReadOnlyCollection<KeyValuePair<UtilityKey, float>> variableUtilities)
         { return CalculateScore(variableUtilities.Select(x => x.Value).ToArray()); }
-
-        public static float CalculateScore(this IReadOnlyCollection<float> utilities)
-        {
-            var score = 1.0f;
-            var compensationFactor = (float)(1.0 - 1.0 / utilities.Count);
-            foreach (var utility in utilities)
-            {
-                var modification = (float)((1.0 - utility) * compensationFactor);
-                var scaledUtility = utility + (modification * utility);
-                score *= scaledUtility;
-            }
-            return score;
-        }
 
         public static float CalculateScore(params float[] utilities)
+        { return CalculateScore(utilities as IReadOnlyCollection<float>); }
+
+        public static float CalculateScore(this IReadOnlyCollection<float> utilities)
         {
             var score = 1.0f;
-            var compensationFactor = (float)(1.0 - 1.0 / utilities.Length);
+            var compensationFactor = (float)(1.0 - 1.0 / utilities.Count);
             foreach (var utility in utilities)
             {
                 var modification = (float)((1.0 - utility) * compensationFactor);

src/OpenRpg.AdviceEngine/OpenRpg.AdviceEngine.csproj

@@ -8,8 +8,8 @@
         <PackageProjectUrl>https://github.com/openrpg/OpenRpg.AdviceEngine</PackageProjectUrl>
         <Description>A Utility AI flavoured framework to provide advice about what entities should do</Description>
         <PackageTags>rpg game-development xna monogame unity godot</PackageTags>
-        <TargetFramework>netstandard2.1</TargetFramework>
-        <LangVersion>8</LangVersion>
+        <TargetFramework>net10.0</TargetFramework>
+        <LangVersion>14</LangVersion>
     </PropertyGroup>
 
     <ItemGroup>

src/OpenRpg.Cards/Effects/CardEffects.cs

@@ -2,15 +2,15 @@
 using System.Collections.Generic;
 using OpenRpg.Core.Common;
 using OpenRpg.Core.Effects;
-using OpenRpg.Entities.Effects;
 
 namespace OpenRpg.Cards.Effects
 {
-    public class CardEffects : IHasDataId, IHasLocaleDescription, IHasEffects
+    public class CardEffects : IHasDataId, IHasLocaleDescription
     {
         public int Id { get; set; }
         public string NameLocaleId { get; set; }
         public string DescriptionLocaleId { get; set; }
+
         public IReadOnlyCollection<IEffect> Effects { get; set; } = Array.Empty<IEffect>();
     }
 }

src/OpenRpg.Cards/Genres/AbilityCard.cs

@@ -4,7 +4,6 @@
 using OpenRpg.Cards.Types;
 using OpenRpg.Combat.Abilities;
 using OpenRpg.Core.Effects;
-using OpenRpg.Entities.Effects;
 
 namespace OpenRpg.Cards.Genres
 {

src/OpenRpg.Cards/Genres/ClassCard.cs

@@ -1,10 +1,11 @@
 using OpenRpg.Cards.Genres.Conventions;
 using OpenRpg.Cards.Types;
 using OpenRpg.Entities.Classes.Templates;
+using OpenRpg.Entities.Classes.Variables;
 
 namespace OpenRpg.Cards.Genres
 {
-    public class ClassCard : GenericDataCardWithEffects<ClassTemplate>
+    public class ClassCard : TemplateDataCardWithEffects<ClassTemplate, ClassTemplateVariables>
     {
         public override int CardType => CardTypes.ClassCard;
 

src/OpenRpg.Cards/Genres/Conventions/GenericDataCard.cs

@@ -2,7 +2,6 @@
 using OpenRpg.Cards.Variables;
 using OpenRpg.Core.Common;
 using OpenRpg.Core.Effects;
-using OpenRpg.Entities.Effects;
 
 namespace OpenRpg.Cards.Genres.Conventions
 {

src/OpenRpg.Cards/Genres/Conventions/TemplateDataCardWithEffects.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using OpenRpg.Core.Common;
+using OpenRpg.Core.Effects;
+using OpenRpg.Core.Templates;
+using OpenRpg.Core.Templates.Variables;
+using OpenRpg.Entities.Effects;
+using OpenRpg.Entities.Extensions;
+
+namespace OpenRpg.Cards.Genres.Conventions
+{
+    public abstract class TemplateDataCardWithEffects<T,TTemplateVars> : GenericDataCard<T>
+        where T : ITemplate<TTemplateVars> 
+        where TTemplateVars : ITemplateVariables
+    {
+        protected TemplateDataCardWithEffects(T data) : base(data)
+        { }
+
+        public override IReadOnlyCollection<IEffect> Effects => Data.Variables.Effects;
+    }
+}

src/OpenRpg.Cards/Genres/EffectCard.cs

@@ -1,12 +1,16 @@
-using OpenRpg.Cards.Effects;
+using System.Collections.Generic;
+using OpenRpg.Cards.Effects;
 using OpenRpg.Cards.Genres.Conventions;
 using OpenRpg.Cards.Types;
+using OpenRpg.Core.Effects;
 
 namespace OpenRpg.Cards.Genres
 {
-    public class EffectCard : GenericDataCardWithEffects<CardEffects>
+    public class EffectCard : GenericDataCard<CardEffects>
     {
         public override int CardType => CardTypes.EffectCard;
+
+        public override IReadOnlyCollection<IEffect> Effects => Data.Effects;
 
         public EffectCard(CardEffects data) : base(data)
         {

src/OpenRpg.Cards/Genres/ItemCard.cs

@@ -3,6 +3,7 @@
 using OpenRpg.Cards.Variables;
 using OpenRpg.Core.Effects;
 using OpenRpg.Entities.Effects;
+using OpenRpg.Entities.Extensions;
 using OpenRpg.Items;
 
 namespace OpenRpg.Cards.Genres
@@ -18,6 +19,6 @@ public ItemCard(Item item)
 
         public string NameLocaleId => Data.Template.NameLocaleId;
         public string DescriptionLocaleId => Data.Template.DescriptionLocaleId;
-        public IReadOnlyCollection<IEffect> Effects => Data.Template.Effects;
+        public IReadOnlyCollection<IEffect> Effects => Data.Template.Variables.Effects;
     }
 }

src/OpenRpg.Cards/Genres/RaceCard.cs

@@ -1,10 +1,11 @@
 using OpenRpg.Cards.Genres.Conventions;
 using OpenRpg.Cards.Types;
 using OpenRpg.Entities.Races.Templates;
+using OpenRpg.Entities.Races.Variables;
 
 namespace OpenRpg.Cards.Genres
 {
-    public class RaceCard : GenericDataCardWithEffects<RaceTemplate>
+    public class RaceCard : TemplateDataCardWithEffects<RaceTemplate, RaceTemplateVariables>
     {
         public override int CardType => CardTypes.RaceCard;