[Add] Yacht scoring system with Balatro-like modifier pipeline

Implements the core game loop for Yacht dice: 5-dice rolling with lock/unlock, 3 rolls per turn, 13 standard scoring categories, and an extensible ScriptableObject-based modifier system that applies additive then multiplicative bonuses (chips+mult pattern). Includes two test modifiers: BonusForOnes (+10 per 1) and MultiplierForSixes (x6 per 6). Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-27 03:01:19 +07:00
parent b33017a320
commit f49cda7cdc
10 changed files with 517 additions and 0 deletions
@@ -0,0 +1,34 @@
+using UnityEngine;
+
+public sealed class DebugGameInput : MonoBehaviour
+{
+    [SerializeField] private GameManager gameManager;
+
+    private void Update()
+    {
+        if (Input.GetKeyDown(KeyCode.Space))
+            gameManager.Roll();
+
+        // 1-5: toggle lock on dice 0-4
+        if (Input.GetKeyDown(KeyCode.Alpha1)) gameManager.ToggleDiceLock(0);
+        if (Input.GetKeyDown(KeyCode.Alpha2)) gameManager.ToggleDiceLock(1);
+        if (Input.GetKeyDown(KeyCode.Alpha3)) gameManager.ToggleDiceLock(2);
+        if (Input.GetKeyDown(KeyCode.Alpha4)) gameManager.ToggleDiceLock(3);
+        if (Input.GetKeyDown(KeyCode.Alpha5)) gameManager.ToggleDiceLock(4);
+
+        // Score categories
+        if (Input.GetKeyDown(KeyCode.F1))  gameManager.ScoreInCategory(YachtCategory.Ones);
+        if (Input.GetKeyDown(KeyCode.F2))  gameManager.ScoreInCategory(YachtCategory.Twos);
+        if (Input.GetKeyDown(KeyCode.F3))  gameManager.ScoreInCategory(YachtCategory.Threes);
+        if (Input.GetKeyDown(KeyCode.F4))  gameManager.ScoreInCategory(YachtCategory.Fours);
+        if (Input.GetKeyDown(KeyCode.F5))  gameManager.ScoreInCategory(YachtCategory.Fives);
+        if (Input.GetKeyDown(KeyCode.F6))  gameManager.ScoreInCategory(YachtCategory.Sixes);
+        if (Input.GetKeyDown(KeyCode.F7))  gameManager.ScoreInCategory(YachtCategory.ThreeOfAKind);
+        if (Input.GetKeyDown(KeyCode.F8))  gameManager.ScoreInCategory(YachtCategory.FourOfAKind);
+        if (Input.GetKeyDown(KeyCode.F9))  gameManager.ScoreInCategory(YachtCategory.FullHouse);
+        if (Input.GetKeyDown(KeyCode.F10)) gameManager.ScoreInCategory(YachtCategory.SmallStraight);
+        if (Input.GetKeyDown(KeyCode.F11)) gameManager.ScoreInCategory(YachtCategory.LargeStraight);
+        if (Input.GetKeyDown(KeyCode.F12)) gameManager.ScoreInCategory(YachtCategory.Yacht);
+        if (Input.GetKeyDown(KeyCode.C))   gameManager.ScoreInCategory(YachtCategory.Chance);
+    }
+}
@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+public sealed class DiceManager : MonoBehaviour
+{
+    [SerializeField] private List<DiceRoller> diceRollers = new();
+
+    public event Action OnAllDiceSettled;
+    public event Action<int, int> OnDieSettled;
+
+    public int DiceCount => diceRollers.Count;
+
+    private bool[] locked;
+    private int[] currentValues;
+    private int pendingCount;
+
+    private void Awake()
+    {
+        int count = diceRollers.Count;
+        locked = new bool[count];
+        currentValues = new int[count];
+    }
+
+    public bool IsLocked(int index) => locked[index];
+
+    public void ToggleLock(int index)
+    {
+        locked[index] = !locked[index];
+    }
+
+    public void SetLocked(int index, bool isLocked)
+    {
+        locked[index] = isLocked;
+    }
+
+    public void UnlockAll()
+    {
+        for (int i = 0; i < locked.Length; i++) locked[i] = false;
+    }
+
+    public void RollUnlocked()
+    {
+        for (int i = 0; i < diceRollers.Count; i++)
+            if (diceRollers[i].IsRolling) return;
+
+        pendingCount = 0;
+
+        for (int i = 0; i < diceRollers.Count; i++)
+        {
+            if (locked[i]) continue;
+
+            pendingCount++;
+            int capturedIndex = i;
+
+            void Handler(int value)
+            {
+                diceRollers[capturedIndex].OnRollFinished -= Handler;
+                currentValues[capturedIndex] = value;
+                OnDieSettled?.Invoke(capturedIndex, value);
+
+                pendingCount--;
+                if (pendingCount <= 0)
+                    OnAllDiceSettled?.Invoke();
+            }
+
+            diceRollers[i].OnRollFinished += Handler;
+            diceRollers[i].Roll();
+        }
+
+        if (pendingCount == 0)
+            OnAllDiceSettled?.Invoke();
+    }
+
+    public int[] GetCurrentValues()
+    {
+        int[] copy = new int[currentValues.Length];
+        Array.Copy(currentValues, copy, currentValues.Length);
+        return copy;
+    }
+
+    public int GetValue(int index) => currentValues[index];
+
+    public bool IsAnyRolling
+    {
+        get
+        {
+            for (int i = 0; i < diceRollers.Count; i++)
+                if (diceRollers[i].IsRolling) return true;
+            return false;
+        }
+    }
+
+    public void ReadAllValues()
+    {
+        for (int i = 0; i < diceRollers.Count; i++)
+        {
+            var diceComponent = diceRollers[i].GetComponent<Dice>();
+            if (diceComponent != null && diceComponent.TryGetTopValue(out int val))
+                currentValues[i] = val;
+        }
+    }
+}
@@ -0,0 +1,100 @@
+using System;
+using UnityEngine;
+
+public sealed class GameManager : MonoBehaviour
+{
+    [Header("References")]
+    [SerializeField] private DiceManager diceManager;
+    [SerializeField] private ScoringSystem scoringSystem;
+
+    [Header("Settings")]
+    [SerializeField] private int maxRollsPerTurn = 3;
+
+    public int CurrentRoll { get; private set; }
+    public int CurrentTurn { get; private set; }
+
+    public bool CanRoll => CurrentRoll < maxRollsPerTurn && !diceManager.IsAnyRolling;
+    public bool CanScore => CurrentRoll > 0 && !diceManager.IsAnyRolling;
+    public bool IsGameOver => scoringSystem.IsComplete;
+
+    public event Action<int> OnTurnStarted;
+    public event Action<int> OnRollComplete;
+    public event Action<YachtCategory, int> OnScored;
+    public event Action<int> OnGameOver;
+
+    private void Start()
+    {
+        StartNewGame();
+    }
+
+    public void StartNewGame()
+    {
+        scoringSystem.ResetScorecard();
+        CurrentTurn = 0;
+        StartNewTurn();
+    }
+
+    private void StartNewTurn()
+    {
+        CurrentTurn++;
+        CurrentRoll = 0;
+        diceManager.UnlockAll();
+        OnTurnStarted?.Invoke(CurrentTurn);
+        Debug.Log($"=== Turn {CurrentTurn} ===");
+    }
+
+    public void Roll()
+    {
+        if (!CanRoll) return;
+
+        CurrentRoll++;
+        diceManager.OnAllDiceSettled += HandleAllDiceSettled;
+        diceManager.RollUnlocked();
+    }
+
+    private void HandleAllDiceSettled()
+    {
+        diceManager.OnAllDiceSettled -= HandleAllDiceSettled;
+
+        int[] values = diceManager.GetCurrentValues();
+        Debug.Log($"Roll {CurrentRoll}/{maxRollsPerTurn} | Dice: [{string.Join(", ", values)}]");
+
+        OnRollComplete?.Invoke(CurrentRoll);
+    }
+
+    public void ToggleDiceLock(int index)
+    {
+        if (diceManager.IsAnyRolling) return;
+        if (CurrentRoll == 0) return;
+        diceManager.ToggleLock(index);
+
+        bool isLocked = diceManager.IsLocked(index);
+        Debug.Log($"Die {index + 1} (value={diceManager.GetValue(index)}): {(isLocked ? "LOCKED" : "UNLOCKED")}");
+    }
+
+    public void ScoreInCategory(YachtCategory category)
+    {
+        if (!CanScore) return;
+        if (scoringSystem.IsCategoryUsed(category)) return;
+
+        int[] values = diceManager.GetCurrentValues();
+        ScoreResult result = scoringSystem.ScoreCategory(values, category);
+
+        Debug.Log($"Scored {category}: base={result.BaseScore}, " +
+                  $"bonus=+{result.FlatBonus}, mult=x{result.Multiplier:F1}, " +
+                  $"FINAL={result.FinalScore} | Total={scoringSystem.TotalScore}");
+
+        OnScored?.Invoke(category, result.FinalScore);
+
+        if (scoringSystem.IsComplete)
+        {
+            int total = scoringSystem.TotalScore;
+            Debug.Log($"*** GAME OVER *** Total Score: {total}");
+            OnGameOver?.Invoke(total);
+        }
+        else
+        {
+            StartNewTurn();
+        }
+    }
+}