Battle/feature - Commands

Assets/QuantumUser/Simulation/Battle/Qtn/Player/BattlePlayerInput.qtn

@@ -4,14 +4,10 @@ input
     int                     DebugNumber;
     BattleMovementInputType MovementInput;
     bool                    MovementDirectionIsNormalized;
-    BattleGridPosition      MovementPositionTarget;
-    FPVector2               MovementPositionMove;
-    FPVector2               MovementDirection;
+    BattleGridPosition      MovementGridPosition;
+    FPVector2               MovementVector;
     bool                    RotationInput;
     FP                      RotationValue;
-    bool                    AbilityActivate;
-    int                     PlayerCharacterNumber;
-    bool                    GiveUpInput;
     BattleSpecialInput      Special;
 }
 

Assets/QuantumUser/Simulation/Battle/Scripts/BattleDebugUtils.cs

@@ -67,24 +67,6 @@ public static InputDebugInfo GenerateDebugInfo(Input* input)
                 inputDebugSummary += "Rotate";
                 inputNotEmpty = true;
             }
-            if (input->AbilityActivate != false)
-            {
-                if (inputDebugSummary != "") inputDebugSummary += ", ";
-                inputDebugSummary += "Ability Activate";
-                inputNotEmpty = true;
-            }
-            if (input->PlayerCharacterNumber > -1)
-            {
-                if (inputDebugSummary != "") inputDebugSummary += ", ";
-                inputDebugSummary += "Character Swap";
-                inputNotEmpty = true;
-            }
-            if (input->GiveUpInput != false)
-            {
-                if (inputDebugSummary != "") inputDebugSummary += ", ";
-                inputDebugSummary += "Give Up";
-                inputNotEmpty = true;
-            }
 
             if (inputNotEmpty)
             {
@@ -95,24 +77,16 @@ public static InputDebugInfo GenerateDebugInfo(Input* input)
                                   "    MovementInput:                 {0},\n" +
                                   "    MovementDirectionIsNormalized: {1},\n" +
                                   "    MovementPositionTarget:        {2},\n" +
-                                  "    MovementPositionMove:          {3},\n" +
-                                  "    MovementDirection:             {4},\n" +
-                                  "    RotationInput:                 {5},\n" +
-                                  "    RotationValue:                 {6},\n" +
-                                  "    AbilityActivate:               {7},\n" +
-                                  "    PlayerCharacterNumber:         {8},\n" +
-                                  "    GiveUpInput:                   {9}\n" +
+                                  "    MovementVector:                {3},\n" +
+                                  "    RotationInput:                 {4},\n" +
+                                  "    RotationValue:                 {5},\n" +
                                   "}}",
                                   input->MovementInput,
                                   input->MovementDirectionIsNormalized,
-                                  input->MovementPositionTarget.ConvertToString(),
-                                  input->MovementPositionMove,
-                                  input->MovementDirection,
+                                  input->MovementGridPosition.ConvertToString(),
+                                  input->MovementVector,
                                   input->RotationInput,
-                                  input->RotationValue,
-                                  input->AbilityActivate,
-                                  input->PlayerCharacterNumber,
-                                  input->GiveUpInput
+                                  input->RotationValue
                     )
                 );
             }

Assets/QuantumUser/Simulation/Battle/Scripts/Game/BattleCommands.cs

@@ -0,0 +1,119 @@
+/// @file BattleCommands.cs
+/// <summary>
+/// Contains @cref{Battle.QSimulation.Game,BattleCommand} class and all battle commands
+///
+/// See [{Custom Quantum Commands}](#page-concepts-commands) for more info.
+/// </summary>
+
+// System usings
+using System.Runtime.CompilerServices;
+
+// Quantum usings
+using Quantum;
+using Photon.Deterministic;
+
+namespace Battle.QSimulation.Game
+{
+    /// <summary>
+    /// Abstract base class for all deterministic battle commands.<br/>
+    /// All new commands must be added to the <see cref="Type"/> enum.
+    /// </summary>
+    ///
+    /// See [{BattleCommand (base class)}](#page-concepts-commands-battle-qcommand) for more info.
+    public abstract class BattleCommand : DeterministicCommand
+    {
+        /// <summary>
+        /// Type of the command. None if no command.
+        /// </summary>
+        public enum Type
+        {
+            /// <summary>No command</summary>
+            None,
+            /// <summary><See cref="BattleGiveUpQCommand"/></summary>
+            GiveUp,
+            /// <summary><See cref="BattleCharacterAbilityQCommand"/></summary>
+            ActivateAbility,
+            /// <summary><See cref="BattleCharacterSwapQCommand"/></summary>
+            SwapCharacter
+        }
+
+        public override void Serialize(BitStream stream) { }
+
+        public abstract Type BattleCommandType { get; }
+
+        /// <summary>
+        /// Fetches a command for a <paramref name="playerRef"/>  and returns its <see cref="Type"/>. The <paramref name="commandData"/> out parameter contains the command itself.
+        /// </summary>
+        ///
+        /// <param name="f">The current simulation frame.</param>
+        /// <param name="playerRef">Reference to the player whose command is fetched.</param>
+        /// <param name="commandData">Contains the command, or null if there isn't one. (<b>out param</b>)</param>
+        ///
+        /// <returns>
+        /// The <see cref="Type"/> of the command, or <see cref="Type.None"/> if no command was found.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Type GetCommand(Frame f, PlayerRef playerRef, out BattleCommand commandData)
+        {
+            commandData = (BattleCommand)f.GetPlayerCommand(playerRef);
+            if (commandData == null) return Type.None;
+            return commandData.BattleCommandType;
+        }
+    }
+
+    /// <summary>
+    /// A deterministic command that triggers the ability activation for a specific player.
+    /// </summary>
+    ///
+    /// See [{Custom Quantum Commands}](#page-concepts-commands) for more info.
+    public class BattleCharacterAbilityQCommand : BattleCommand
+    {
+        /// <summary>
+        /// Gets the command <see cref="BattleCommand.Type">Type</see> associated with this command.<br/>
+        /// Always returns <see cref="BattleCommand.Type.ActivateAbility">Type.ActivateAbility</see>.
+        /// </summary>
+        public override Type BattleCommandType => Type.ActivateAbility;
+    }
+
+    /// <summary>
+    /// A deterministic command that triggers the character swapping logic for a specific player.
+    /// </summary>
+    ///
+    /// See [{Custom Quantum Commands}](#page-concepts-commands) for more info.
+    public class BattleCharacterSwapQCommand : BattleCommand
+    {
+        /// <summary>
+        /// Gets the command <see cref="BattleCommand.Type">Type</see> associated with this command.<br/>
+        /// Always returns <see cref="BattleCommand.Type.SwapCharacter">Type.SwapCharacter</see>.
+        /// </summary>
+        public override Type BattleCommandType => Type.SwapCharacter;
+
+        /// <summary>
+        /// The number of the character the player is attempting to swap to.
+        /// </summary>
+        public int CharacterNumber;
+
+        /// <summary>
+        /// Serializes the character number into the bitstream for network transmission.
+        /// </summary>
+        /// <param name="stream">The bitstream to write to</param>
+        public override void Serialize(BitStream stream)
+        {
+            stream.Serialize(ref CharacterNumber);
+        }
+    }
+
+    /// <summary>
+    /// A deterministic command that triggers the give up logic for a specific player.
+    /// </summary>
+    ///
+    /// See [{Custom Quantum Commands}](#page-concepts-commands) for more info.
+    public class BattleGiveUpQCommand : BattleCommand
+    {
+        /// <summary>
+        /// Gets the command <see cref="BattleCommand.Type">Type</see> associated with this command.<br/>
+        /// Always returns <see cref="BattleCommand.Type.GiveUp">Type.GiveUp</see>.
+        /// </summary>
+        public override Type BattleCommandType => Type.GiveUp;
+    }
+}

Assets/QuantumUser/Simulation/Battle/Scripts/Player/BattlePlayerBotController.cs

@@ -167,14 +167,10 @@ public static void GetBotInput(Frame f, bool isInPlay, BattlePlayerDataQComponen
                 IsValid                       = true,
                 MovementInput                 = movementInput,
                 MovementDirectionIsNormalized = false,
-                MovementPositionTarget        = predictedGridPosition,
-                MovementPositionMove          = FPVector2.Zero,
-                MovementDirection             = FPVector2.Zero,
+                MovementGridPosition          = predictedGridPosition,
+                MovementVector                = FPVector2.Zero,
                 RotationInput                 = false,
-                RotationValue                 = FP._0,
-                PlayerCharacterNumber         = -1,
-                GiveUpInput                   = false,
-                AbilityActivate               = false
+                RotationValue                 = FP._0
             };
         }
     }

Assets/QuantumUser/Simulation/Battle/Scripts/Player/BattlePlayerMovementController.cs

@@ -93,13 +93,13 @@ public static void UpdateMovement(Frame f, BattlePlayerDataQComponent* playerDat
                     break;
 
                 case BattleMovementInputType.PositionTarget:
-                    ClampGridPosition(playerData, input->MovementPositionTarget, out playerData->TargetPosition);
+                    ClampGridPosition(playerData, input->MovementGridPosition, out playerData->TargetPosition);
                     playerData->HasTargetPosition = true;
                     playerData->ViewPosition = playerData->TargetPosition;
                     break;
 
                 case BattleMovementInputType.PositionMove:
-                    positionNext = FPVector2.MoveTowards(transform->Position, input->MovementPositionMove, playerData->Stats.Speed * f.DeltaTime);
+                    positionNext = FPVector2.MoveTowards(transform->Position, input->MovementVector, playerData->Stats.Speed * f.DeltaTime);
                     if (ClampAndSnapWorldPosition(playerData, positionNext, out FPVector2 clampedNext))
                     {
                         positionNext = clampedNext;
@@ -108,7 +108,7 @@ public static void UpdateMovement(Frame f, BattlePlayerDataQComponent* playerDat
                     break;
 
                 case BattleMovementInputType.Direction:
-                    FPVector2 movementDirection = input->MovementDirection * (input->MovementDirectionIsNormalized ? playerData->Stats.Speed : FP._1);
+                    FPVector2 movementDirection = input->MovementVector * (input->MovementDirectionIsNormalized ? playerData->Stats.Speed : FP._1);
                     positionNext = transform->Position + FPVector2.ClampMagnitude(movementDirection, playerData->Stats.Speed) * f.DeltaTime;
                     if (ClampAndSnapWorldPosition(playerData, positionNext, out FPVector2 clampedPosition))
                     {