Implement Fort Fight minigame (#75)

Co-authored-by: Michal Pikulski <michal.a.pikulski@gmail.com>
Reviewed-on: #75

Assets/Scripts/Minigames/FortFight/UI/GameplayPage.cs

@@ -0,0 +1,204 @@
+using Core;
+using UnityEngine;
+using TMPro;
+using UI.Core;
+using Minigames.FortFight.Core;
+using Minigames.FortFight.Data;
+using Pixelplacement;
+
+namespace Minigames.FortFight.UI
+{
+    /// <summary>
+    /// Main gameplay UI page for Fort Fight minigame.
+    /// Displays turn info. Turn actions now handled via slingshot input system.
+    /// </summary>
+    public class GameplayPage : UIPage
+    {
+        [Header("UI Elements")]
+        [SerializeField] private TextMeshProUGUI turnIndicatorText;
+        [SerializeField] private TextMeshProUGUI currentPlayerText;
+        
+        [Header("Optional Visual Elements")]
+        [SerializeField] private CanvasGroup canvasGroup;
+        [SerializeField] private GameObject playerActionPanel;
+        [SerializeField] private GameObject aiTurnPanel;
+        
+        private TurnManager turnManager;
+        
+        #region Initialization
+        
+        internal override void OnManagedAwake()
+        {
+            base.OnManagedAwake();
+            
+            // Validate references
+            ValidateReferences();
+            
+            // Note: takeActionButton is no longer used - turns handled via slingshot input
+            
+            // Set up canvas group
+            if (canvasGroup == null)
+            {
+                canvasGroup = GetComponent<CanvasGroup>();
+            }
+        }
+        
+        internal override void OnManagedStart()
+        {
+            base.OnManagedStart();
+            
+            // Get turn manager reference via singleton
+            turnManager = TurnManager.Instance;
+            
+            if (turnManager != null)
+            {
+                turnManager.OnTurnStarted += OnTurnStarted;
+                turnManager.OnTurnEnded += OnTurnEnded;
+            }
+            else
+            {
+                Logging.Error("[GameplayPage] TurnManager not found!");
+            }
+        }
+        
+        private void ValidateReferences()
+        {
+            if (turnIndicatorText == null)
+            {
+                Logging.Warning("[GameplayPage] Turn indicator text not assigned!");
+            }
+            
+            if (currentPlayerText == null)
+            {
+                Logging.Warning("[GameplayPage] Current player text not assigned!");
+            }
+            
+            // Note: takeActionButton and actionButtonText are no longer used
+            // Turns are now handled automatically via slingshot input system
+        }
+        
+        #endregion
+
+        #region Turn Events
+        
+        /// <summary>
+        /// Called when a new turn starts
+        /// </summary>
+        private void OnTurnStarted(PlayerData currentPlayer, TurnState turnState)
+        {
+            Logging.Debug($"[GameplayPage] Turn started - Player: {currentPlayer.PlayerName}, State: {turnState}");
+            
+            UpdateTurnUI(currentPlayer, turnState);
+        }
+        
+        /// <summary>
+        /// Called when the current turn ends
+        /// </summary>
+        private void OnTurnEnded(PlayerData player)
+        {
+            Logging.Debug($"[GameplayPage] Turn ended for {player.PlayerName}");
+        }
+        
+        #endregion
+
+        #region UI Updates
+        
+        /// <summary>
+        /// Update the UI to reflect current turn state
+        /// </summary>
+        private void UpdateTurnUI(PlayerData currentPlayer, TurnState turnState)
+        {
+            // Update turn counter
+            if (turnIndicatorText != null && turnManager != null)
+            {
+                turnIndicatorText.text = $"Turn {turnManager.TurnCount + 1}";
+            }
+            
+            // Update current player display
+            if (currentPlayerText != null)
+            {
+                currentPlayerText.text = $"{currentPlayer.PlayerName}'s Turn";
+            }
+            
+            // Show/hide appropriate panels based on turn state
+            if (turnState == TurnState.AITurn)
+            {
+                // AI turn - hide player controls
+                if (playerActionPanel != null)
+                {
+                    playerActionPanel.SetActive(false);
+                }
+                
+                if (aiTurnPanel != null)
+                {
+                    aiTurnPanel.SetActive(true);
+                }
+            }
+            else if (turnState == TurnState.PlayerOneTurn || turnState == TurnState.PlayerTwoTurn)
+            {
+                // Player turn - show controls
+                if (playerActionPanel != null)
+                {
+                    playerActionPanel.SetActive(true);
+                }
+                
+                if (aiTurnPanel != null)
+                {
+                    aiTurnPanel.SetActive(false);
+                }
+            }
+        }
+        
+        #endregion
+
+        #region Transitions
+        
+        protected override void DoTransitionIn(System.Action onComplete)
+        {
+            // Simple fade in if canvas group is available
+            if (canvasGroup != null)
+            {
+                canvasGroup.alpha = 0f;
+                Tween.CanvasGroupAlpha(canvasGroup, 1f, transitionDuration, 0f, Tween.EaseOut, 
+                    completeCallback: () => onComplete?.Invoke());
+            }
+            else
+            {
+                onComplete?.Invoke();
+            }
+        }
+        
+        protected override void DoTransitionOut(System.Action onComplete)
+        {
+            // Simple fade out if canvas group is available
+            if (canvasGroup != null)
+            {
+                Tween.CanvasGroupAlpha(canvasGroup, 0f, transitionDuration, 0f, Tween.EaseIn, 
+                    completeCallback: () => onComplete?.Invoke());
+            }
+            else
+            {
+                onComplete?.Invoke();
+            }
+        }
+        
+        #endregion
+
+        #region Cleanup
+        
+        internal override void OnManagedDestroy()
+        {
+            base.OnManagedDestroy();
+            
+            // Unsubscribe from turn manager events
+            if (turnManager != null)
+            {
+                turnManager.OnTurnStarted -= OnTurnStarted;
+                turnManager.OnTurnEnded -= OnTurnEnded;
+            }
+        }
+        
+        #endregion
+    }
+}
+