Adding narrative events.

.github/workflows/unity-tests.yml

@@ -37,6 +37,7 @@ jobs:
           projectPath: .
           unityVersion: 2021.3.12f1
           testMode: editmode
+          githubToken: ${{ secrets.GITHUB_TOKEN }}
           dockerCpuLimit: 2
           dockerMemoryLimit: 8g
 

Assets/Scripts/Conditionals/ConditionalFactory.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+
+/// <summary>
+/// 
+/// </summary>
+public static class ConditionalFactory
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="parameters"></param>
+    /// <returns></returns>
+    private delegate IConditional ConditionalCreator(Dictionary<string, object> parameters);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    private static readonly Dictionary<string, ConditionalCreator> conditionCreators = new Dictionary<string, ConditionalCreator>
+    {
+        { "IsOnSamePlanet", CreateIsOnSamePlanet },
+        { "HasFamilialRelationship", CreateHasFamilialRelationship },
+        { "IsOnOpposingFactions", CreateIsOnOpposingFactions },
+        { "IsOnMission", CreateIsOnMission }
+        // Add more condition types and their creation functions here
+    };
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="conditionType"></param>
+    /// <param name="parameters"></param>
+    /// <returns></returns>
+    /// <exception cref="ArgumentException"></exception>
+    public static IConditional CreateConditional(string conditionType, Dictionary<string, object> parameters)
+    {
+        if (conditionCreators.TryGetValue(conditionType, out var creator))
+        {
+            return creator(parameters);
+        }
+        else
+        {
+            throw new ArgumentException($"Invalid condition type: {conditionType}");
+        }
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="parameters"></param>
+    /// <returns></returns>
+    private static IConditional CreateIsOnSamePlanet(Dictionary<string, object> parameters)
+    {
+        return new GenericConditional(IsOnSamePlanet, parameters);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="parameters"></param>
+    /// <returns></returns>
+    private static IConditional CreateHasFamilialRelationship(Dictionary<string, object> parameters)
+    {
+        return new GenericConditional(HasFamilialRelationship, parameters);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="parameters"></param>
+    /// <returns></returns>
+    private static IConditional CreateIsOnOpposingFactions(Dictionary<string, object> parameters)
+    {
+        return new GenericConditional(IsOnOpposingFactions, parameters);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="parameters"></param>
+    /// <returns></returns>
+    private static IConditional CreateIsOnMission(Dictionary<string, object> parameters)
+    {
+        return new GenericConditional(IsOnMission, parameters);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="game"></param>
+    /// <param name="parameters"></param>
+    /// <returns></returns>
+    private static bool IsOnSamePlanet(Game game, Dictionary<string, object> parameters)
+    {
+        string gameID1 = (string)parameters["GameID1"];
+        string gameID2 = (string)parameters["GameID2"];
+        // Implement the logic here
+        return true; // Placeholder
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="game"></param>
+    /// <param name="parameters"></param>
+    /// <returns></returns>
+    private static bool HasFamilialRelationship(Game game, Dictionary<string, object> parameters)
+    {
+        string gameID1 = (string)parameters["GameID1"];
+        string gameID2 = (string)parameters["GameID2"];
+        // Implement the logic here
+        return true; // Placeholder
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="game"></param>
+    /// <param name="parameters"></param>
+    /// <returns></returns>
+    private static bool IsOnOpposingFactions(Game game, Dictionary<string, object> parameters)
+    {
+        string gameID1 = (string)parameters["GameID1"];
+        string gameID2 = (string)parameters["GameID2"];
+        // Implement the logic here
+        return true; // Placeholder
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="game"></param>
+    /// <param name="parameters"></param>
+    /// <returns></returns>
+    private static bool IsOnMission(Game game, Dictionary<string, object> parameters)
+    {
+        string gameID = (string)parameters["GameID"];
+        // Implement the logic here
+        return true; // Placeholder
+    }
+}

Assets/Scripts/Conditionals/GenericConditional.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+
+/// <summary>
+/// 
+/// </summary>
+public class GenericConditional : IConditional
+{
+    private readonly Func<Game, Dictionary<string, object>, bool> callback;
+    private Dictionary<string, object> parameters;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="callback"></param>
+    /// <param name="parameters"></param>
+    public GenericConditional(Func<Game, Dictionary<string, object>, bool> callback, Dictionary<string, object> parameters)
+    {
+        this.callback = callback;
+        this.parameters = parameters;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="game"></param>
+    /// <returns></returns>
+    public bool IsMet(Game game)
+    {
+        return callback(game, parameters);
+    }
+}

Assets/Scripts/Events/ICondition.cs → Assets/Scripts/Conditionals/IConditional.cs

@@ -1,7 +1,7 @@
 /// <summary>
 /// Represents a condition that must be met for an event or action to proceed.
 /// </summary>
-public interface ICondition
+public interface IConditional
 {
     /// <summary>
     /// Evaluates the condition in the context of the provided game instance.

Assets/Scripts/Events/GameEvent.cs

@@ -20,7 +20,12 @@ public abstract class GameEvent : GameEntity
     public event Action<GameEvent> OnEventTriggered;
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="GameEvent"/> class with the specified parameters.
+    /// Default constructor used for serialization.
+    /// </summary>
+    public GameEvent() { }
+
+    /// <summary>
+    /// 
     /// </summary>
     /// <param name="scheduledTick">The tick at which the event is scheduled to occur.</param>
     protected GameEvent(int scheduledTick)

Assets/Scripts/Events/MissionEvent.cs

@@ -6,7 +6,12 @@ public class MissionEvent : GameEvent
     public Mission Mission { get; private set; }
 
     /// <summary>
-    /// Initializes a new instance of the MissionEvent class.
+    /// Default constructor used for serialization.
+    /// </summary>
+    public MissionEvent() { }
+
+    /// <summary>
+    /// Initializes a <see cref="MissionEvent"/> with the specified parameters. 
     /// </summary>
     /// <param name="scheduledTick">The tick at which the event is scheduled to occur.</param>
     /// <param name="mission">The mission that is being executed.</param>

Assets/Scripts/Events/NarrativeEvent.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using System;
+
+public class NarrativeEvent : GameEvent
+{
+    public IConditional Conditionals { get; set; }
+    public List<SerializableDictionary<string, object>> ConditionalParams { get; set; }
+
+    /// <summary>
+    /// Default constructor used for serialization.
+    /// </summary>
+    public NarrativeEvent() { }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="scheduledTick"></param>
+    /// <param name="conditionals"></param>
+    public NarrativeEvent(int scheduledTick, List<IConditional> conditionals) : base(scheduledTick) { }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="game"></param>
+    protected override void TriggerEvent(Game game)
+    {
+        // @TODO: Implement trigger.
+    }
+}

Assets/Scripts/Managers/GameEventManager.cs

@@ -4,11 +4,11 @@
 /// <summary>
 /// Manages game events and their scheduling.
 /// </summary>
-public class EventManager
+public class GameEventManager
 {
     private readonly Game game;
 
-    public EventManager(Game game)
+    public GameEventManager(Game game)
     {
         this.game = game;
     }

Assets/Scripts/Managers/GameManager.cs

@@ -17,7 +17,7 @@ public enum TickSpeed
 public class GameManager
 {
     private Game currentGame;
-    public EventManager EventManager { get; private set; }
+    public GameEventManager EventManager { get; private set; }
     public MissionManager MissionManager { get; private set; }
     private float? tickInterval;
     private float tickTimer;
@@ -29,7 +29,7 @@ public class GameManager
     public GameManager(Game game)
     {
         currentGame = game;
-        EventManager = new EventManager(game);
+        EventManager = new GameEventManager(game);
         MissionManager = new MissionManager(EventManager);
     }
 

Assets/Scripts/Managers/MissionManager.cs

@@ -8,27 +8,28 @@
 /// </summary>
 public class MissionManager
 {
-    protected EventManager eventManager;
+    protected GameEventManager eventManager;
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="MissionManager"/> class.
+    /// 
     /// </summary>
     /// <param name="eventManager">The event manager.</param>
-    public MissionManager(EventManager eventManager)
+    public MissionManager(GameEventManager eventManager)
     {
         this.eventManager = eventManager;
-        InitializeMissions();
+
+        // Initialize missions (i.e. register event handlers).
+        initializeMissions();
     }
 
     /// <summary>
-    /// Starts a mission by generating a random tick for the mission and scheduling a mission event.
+    /// Initializes the missions by registering event handlers for mission events.
     /// </summary>
-    /// <param name="mission">The mission to start.</param>
-    private void InitializeMissions()
+    private void initializeMissions()
     {
         // Register event handlers for mission events.
         List<MissionEvent> missionEvents = eventManager
-            .GetEventsByType<GameEvent>()
+            .GetEventsByType<MissionEvent>()
             .OfType<MissionEvent>()
             .ToList();
 

Assets/Scripts/Managers/NarrativeEventManager.cs

@@ -0,0 +1,39 @@
+using System.Collections.Generic;
+using System.Linq;
+using System;
+
+/// <summary>
+/// 
+/// </summary>
+public class NarrativeEventManager
+{
+    private GameEventManager eventManager;
+
+    public NarrativeEventManager(GameEventManager eventManager)
+    {
+        this.eventManager = eventManager;
+
+        initializeNarrativeEvents();
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    private void initializeNarrativeEvents()
+    {
+        List<NarrativeEvent> narrativeEvents = eventManager
+            .GetEventsByType<NarrativeEvent>()
+            .OfType<NarrativeEvent>()
+            .ToList();
+
+        foreach(NarrativeEvent narrativeEvent in narrativeEvents)
+        {
+            List<IConditional> conditionals = narrativeEvent.ConditionalParams.Aggregate(new List<IConditional>(), (acc, parameters) => {
+                acc.Add(ConditionalFactory.CreateConditional(narrativeEvent.Conditionals, parameters));
+                return acc;
+            });
+
+        }
+
+    }
+}

Assets/Tests/EditMode/Managers/GameManagerTests.cs

@@ -1,5 +1,4 @@
 using NUnit.Framework;
-using UnityEngine.TestTools;
 using System.Collections;
 
 // Mock GameEvent for testing
@@ -55,12 +54,12 @@ public void TestEventExecutesAtScheduledTick()
         // Simulate 4 ticks (the event should not trigger yet)
         for (int i = 0; i < 4; i++)
         {
-            gameManager.Update(1f);  // Simulate 1 second of game time (1 tick)
+            gameManager.Update(1f); // Simulate 1 second of game time (1 tick)
             Assert.IsFalse(mockEvent.WasExecuted, "Event should not have been executed yet.");
         }
 
         // Simulate 1 more tick (the 5th tick, where the event is scheduled)
-        gameManager.Update(1f);  // Simulate 1 second of game time (1 tick)
+        gameManager.Update(1f); // Simulate 1 second of game time (1 tick)
 
         Assert.IsTrue(mockEvent.WasExecuted, "Event should have been executed at tick 5.");
     }

Assets/Tests/EditMode/Managers/SaveGameManagerTests.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.IO;
 using UnityEngine;
-using UnityEngine.TestTools;
 
 [TestFixture]
 public class SaveGameManagerTests