#13 Transit chore to wait state upon enter events specified in ChoreList config.

src/MultiplayerMod.Test/Game/Chores/States/ChoreStateEventsTest.cs

@@ -138,7 +138,7 @@ StateTransitionConfig config
         var smi = (StateMachine.Instance) chore.GetType().GetProperty("smi").GetValue(chore);
         smi.stateMachine.GetState("root").enterActions?.Clear();
         smi.stateMachine.GetState("root.delivering")?.enterActions?.Clear();
-        var state = smi.stateMachine.GetState("root." + config.StateToMonitorName);
+        var state = config.GetMonitoredState(smi.stateMachine);
         state.enterActions?.Clear();
         chore.Begin(
             new Chore.Precondition.Context {

src/MultiplayerMod.Test/Multiplayer/Patches/Chores/States/DisableChoreStateTransitionTest.cs

@@ -28,6 +28,23 @@ public void SetUp() {
         Singleton<StateMachineManager>.Instance.Clear();
     }
 
+    [Test, TestCaseSource(nameof(EnterTestArgs))]
+    public void ClientStateEnter_DisablesTransition(
+        Type choreType,
+        Func<object[]> choreArgsFunc,
+        Func<Dictionary<int, object?>> stateTransitionArgsFunc,
+        StateTransitionConfig config
+    ) {
+        var statesManager = Runtime.Instance.Dependencies.Get<FakeStatesManager>();
+        statesManager.CalledWithStates.Clear();
+
+        var chore = CreateChore(choreType, choreArgsFunc.Invoke());
+
+        var smi = statesManager.GetSmi(chore);
+        var expectedState = config.GetMonitoredState(smi.stateMachine);
+        Assert.Contains(expectedState, statesManager.CalledWithStates);
+    }
+
     [Test, TestCaseSource(nameof(ExitTestArgs))]
     public void ClientStateExit_DisablesTransition(
         Type choreType,

src/MultiplayerMod.Test/Multiplayer/States/StatesManagerTest.cs

@@ -22,9 +22,14 @@ public static void OneTimeSetUp() {
     [SetUp]
     public void SetUp() {
         CreateTestData();
+        StateMachine.Instance.error = false;
     }
 
-    [Test, TestCaseSource(nameof(ExitTestArgs))]
+    protected static IEnumerable<object[]> TestCases() {
+        return ExitTestArgs().Union(EnterTestArgs());
+    }
+
+    [Test, TestCaseSource(nameof(TestCases))]
     public void AllowTransitionPreparesWaitHostState(
         Type choreType,
         Func<object[]> choreArgsFunc,
@@ -50,21 +55,50 @@ StateTransitionConfig config
         Assert.AreEqual(expectedDictionary, waitHostState.ParametersArgs.Get(smi));
     }
 
+    [Test, TestCaseSource(nameof(EnterTestArgs))]
+    public void EnterArgs_DisableChoreStateTransition(
+        Type choreType,
+        Func<object[]> choreArgsFunc,
+        Func<Dictionary<int, object?>> stateTransitionArgsFunc,
+        StateTransitionConfig config
+    ) {
+        var sm = Singleton<StateMachineManager>.Instance.CreateStateMachine(GetStatesType(choreType));
+        sm.GetState("root").events?.Clear();
+        var statesManager = Runtime.Instance.Dependencies.Get<StatesManager>();
+        var stateToBeSynced = config.GetMonitoredState(sm);
+        statesManager.ReplaceWithWaitState(stateToBeSynced);
+        var chore = CreateChore(choreType, choreArgsFunc.Invoke());
+        var smi = statesManager.GetSmi(chore);
+
+        smi.GoTo(stateToBeSynced);
+
+        var waitHostState = (dynamic) statesManager.GetWaitHostState(chore);
+        Assert.AreEqual(waitHostState, smi.GetCurrentState());
+    }
+
     [Test, TestCaseSource(nameof(ExitTestArgs))]
-    public void DisableChoreStateTransition(
+    public void ExitArgs_DisableChoreStateTransition(
         Type choreType,
         Func<object[]> choreArgsFunc,
         Func<Dictionary<int, object?>> stateTransitionArgsFunc,
         StateTransitionConfig config
     ) {
         var sm = Singleton<StateMachineManager>.Instance.CreateStateMachine(GetStatesType(choreType));
+        sm.defaultState = sm.GetState("root");
+        sm.GetState("root.delivering")?.enterActions?.Clear();
         var statesManager = Runtime.Instance.Dependencies.Get<StatesManager>();
-        statesManager
-            .ReplaceWithWaitState(sm.GetState("root"));
+        var stateToBeSynced = config.GetMonitoredState(sm);
+        statesManager.ReplaceWithWaitState(stateToBeSynced);
         var chore = CreateChore(choreType, choreArgsFunc.Invoke());
         var smi = statesManager.GetSmi(chore);
+        chore.Begin(
+            new Chore.Precondition.Context {
+                consumerState = new ChoreConsumerState(Minion.GetComponent<ChoreConsumer>()),
+                data = PickupableGameObject.GetComponent<Pickupable>()
+            }
+        );
 
-        smi.GoTo("root." + config.StateToMonitorName);
+        smi.GoTo(stateToBeSynced);
 
         var waitHostState = (dynamic) statesManager.GetWaitHostState(chore);
         Assert.AreEqual(waitHostState, smi.GetCurrentState());

src/MultiplayerMod/Game/Chores/Types/StateTransitionConfig.cs

@@ -9,8 +9,6 @@ public record StateTransitionConfig(
     string[] ParameterName
 ) {
 
-    /// TODO: Adjust client logic to wait until receives args from the host.
-    ///
     /// TODO: Execute command on the client
     public static StateTransitionConfig OnEnter(string stateName, params string[] parameterName) =>
         new(TransitionTypeEnum.Enter, stateName, null, parameterName);

src/MultiplayerMod/Multiplayer/Patches/Chores/States/DisableChoreStateTransition.cs

@@ -31,7 +31,7 @@ public static void InitializeStatesPatch(StateMachine __instance) {
         var config = ChoreList.Config[__instance.GetType().DeclaringType].StatesTransitionSync;
 
         foreach (var stateTransitionConfig in config.StateTransitionConfigs.Where(
-                     it => it.TransitionType == TransitionTypeEnum.Exit
+                     it => it.TransitionType is TransitionTypeEnum.Exit or TransitionTypeEnum.Enter
                  )) {
             var stateToBeSynced = stateTransitionConfig.GetMonitoredState(__instance);
             Runtime.Instance.Dependencies.Get<StatesManager>().ReplaceWithWaitState(stateToBeSynced);

src/MultiplayerMod/Multiplayer/States/StatesManager.cs

@@ -45,7 +45,7 @@ public void InjectWaitHostState(StateMachine sm) {
         Activator.CreateInstance(genericType, sm);
     }
 
-    public object GetWaitHostState(Chore chore) {
+    public StateMachine.BaseState GetWaitHostState(Chore chore) {
         return GetWaitHostState(GetSmi(chore));
     }
 
@@ -54,10 +54,11 @@ public StateMachine.Instance GetSmi(Chore chore) {
             .GetValue(chore);
     }
 
-    private object GetWaitHostState(StateMachine.Instance smi) => smi.stateMachine.GetState("root." + StateName);
+    private static StateMachine.BaseState GetWaitHostState(StateMachine.Instance smi) =>
+        smi.stateMachine.GetState("root." + StateName);
 
     private static void TransitToWaitState(StateMachine.Instance smi) {
-        smi.GoTo("root." + StateName);
+        smi.GoTo(GetWaitHostState(smi));
     }
 
 }