跳至主要內容

6. 规则判定

EVOCOSMOS2026/4/13大约 12 分钟

规则判定

6.1 美式8球规则回顾

在上一章中我们实现了瞄准和击球系统，现在需要加入游戏规则，让桌球从一个"物理模拟器"变成一个"完整的游戏"。

规则系统的作用

如果说物理引擎是桌球游戏的"身体"（让球能动），那么规则系统就是桌球游戏的"大脑"（决定该谁打、犯规没有、谁赢了）。没有规则系统，桌球就像一个没有裁判的比赛——虽然球能动、能碰、能进袋，但没有人告诉你这些意味着什么。

核心规则流程图

游戏开始
    ↓
开球（三角形排列）
    ↓
第一次有效进球 → 确定双方花色
    ↓
┌─── 正常回合循环 ───┐
│   当前玩家瞄准击球   │
│         ↓          │
│   所有球停下         │
│         ↓          │
│   判定回合结果       │
│    ┌──┼──┐         │
│   进球 没进 犯规     │
│    │   │   │        │
│   继续 换人 换人+罚  │
│    └──┴──┘         │
└─────────┘
    ↓
打完7球 → 打8号球 → 胜负判定

6.2 球的种类和颜色

在美式8球中，15颗目标球分为两组：

球号颜色组别说明
1-7号纯色球（Solid）纯色组整颗球是一种颜色
8号黑色特殊球最后打的目标
9-15号花色球（Stripe）花色组球中间有一条白色带

颜色定义表

球号颜色名色值组别
1黄色#FFD700纯色
2蓝色#0047AB纯色
3红色#DC143C纯色
4紫色#6B3FA0纯色
5橙色#FF6600纯色
6绿色#006B3C纯色
7栗色#8B0000纯色
8黑色#000000特殊
9黄花#FFD700 + 白条花色
10蓝花#0047AB + 白条花色
11红花#DC143C + 白条花色
12紫花#6B3FA0 + 白条花色
13橙花#FF6600 + 白条花色
14绿花#006B3C + 白条花色
15栗花#8B0000 + 白条花色

如何区分纯色和花色？

  • 纯色球：整颗球都是同一种颜色（除了一个白色小圆圈里写着球号）
  • 花色球：球的上半部分和下半部分是白色，中间一条宽带是彩色（就像穿了一件彩色马甲）

在我们的3D游戏中，可以通过不同的材质来区分——纯色球用纯色材质，花色球用"上下白色+中间彩色"的材质。

6.3 开球——三角形排列

游戏开始时，15颗目标球需要摆成三角形。8号球必须放在三角形的中心（第三排中间）。

三角形排列规则

        第1排:  ●          （1颗球）
       第2排: ● ●         （2颗球）
      第3排: ● ⑧ ●       （3颗球，8号在中间）
     第4排: ● ● ● ●      （4颗球）
    第5排: ● ● ● ● ●     （5颗球）

开球排列的其他规则

  • 8号球必须在三角形中心
  • 三角形最前面（第1排）的那颗球可以随机
  • 两个底角（第5排两端）的球必须一个是纯色，一个是花色

开球位置计算

三角形排列的顶点在球桌的三分之二处（从开球方算起），三角形的底边朝向开球方。

参数值说明
三角形顶点X0球桌中心线上
三角形顶点Z0.51球桌远端
球间距0.057球直径（2 x 半径）

6.4 玩家数据模型

我们需要一个数据结构来存储每位玩家的信息。

玩家信息

属性类型说明
玩家编号int1或2
玩家名称string显示名称
花色分配enum纯色/花色/未分配
已进球列表int[]已打进的目标球号
剩余球数量int还需要打进几颗球

6.5 规则管理器

规则管理器是整个游戏规则的"裁判"，负责判定每一回合的结果。

C
using Godot;
using System;
using System.Collections.Generic;

/// <summary>
/// 游戏状态枚举
/// </summary>
public enum GameState
{
    WaitingToStart,     // 等待开始
    Breaking,           // 开球
    Playing,            // 正常游戏
    PlacingCueBall,     // 放置母球（自由球）
    GameOver            // 游戏结束
}

/// <summary>
/// 花色类型枚举
/// </summary>
public enum BallType
{
    Unassigned,  // 未分配
    Solid,       // 纯色球（1-7号）
    Stripe,      // 花色球（9-15号）
    EightBall    // 8号球
}

/// <summary>
/// 回合结果枚举
/// </summary>
public enum TurnResult
{
    Continue,         // 继续当前玩家回合
    SwitchPlayer,     // 换人
    Foul,             // 犯规（换人+自由球）
    Win,              // 当前玩家获胜
    Lose              // 当前玩家失败
}

/// <summary>
/// 玩家数据
/// </summary>
public class PlayerData
{
    public int PlayerId { get; set; }
    public string PlayerName { get; set; }
    public BallType AssignedType { get; set; } = BallType.Unassigned;
    public List<int> PocketedBalls { get; set; } = new();
    public bool CanShootEight { get; set; } = false;

    public int RemainingBalls
    {
        get
        {
            if (AssignedType == BallType.Unassigned) return 7;
            return 7 - PocketedBalls.Count;
        }
    }
}

/// <summary>
/// 规则管理器 - 桌球游戏的核心规则引擎
/// </summary>
public partial class RuleManager : Node
{
    /// <summary>当前游戏状态</summary>
    public GameState CurrentState { get; private set; } = GameState.WaitingToStart;

    /// <summary>当前玩家编号</summary>
    public int CurrentPlayerId { get; private set; } = 1;

    /// <summary>两位玩家的数据</summary>
    public PlayerData Player1 { get; private set; } = new() { PlayerId = 1, PlayerName = "玩家1" };
    public PlayerData Player2 { get; private set; } = new() { PlayerId = 2, PlayerName = "玩家2" };

    /// <summary>花色是否已分配</summary>
    public bool IsTypeAssigned { get; private set; } = false;

    /// <summary>回合结果事件</summary>
    [Signal] public delegate void TurnResultEventHandler(TurnResult result, string message);

    /// <summary>游戏结束事件</summary>
    [Signal] public delegate void GameOverEventHandler(int winnerId, string message);

    /// <summary>回合切换事件</summary>
    [Signal] public delegate void TurnChangedEventHandler(int newPlayerId);

    /// <summary>状态变化事件</summary>
    [Signal] public delegate void StateChangedEventHandler(GameState newState);

    /// <summary>本轮进袋的球列表</summary>
    private List<int> _turnPocketedBalls = new();

    /// <summary>本轮是否犯规</summary>
    private bool _turnFoul = false;

    /// <summary>本轮母球是否先碰到了合法球</summary>
    private bool _cueBallHitValidBall = false;

    /// <summary>本轮母球是否进袋</summary>
    private bool _cueBallPocketed = false;

    public override void _Ready()
    {
        GD.Print("规则管理器初始化完成");
    }

    /// <summary>
    /// 开始新游戏
    /// </summary>
    public void StartGame()
    {
        // 重置所有数据
        Player1 = new() { PlayerId = 1, PlayerName = "玩家1" };
        Player2 = new() { PlayerId = 2, PlayerName = "玩家2" };
        CurrentPlayerId = 1;
        IsTypeAssigned = false;
        CurrentState = GameState.Breaking;

        GD.Print("新游戏开始！玩家1开球");
        EmitSignal(SignalName.StateChanged, GameState.Breaking);
        EmitSignal(SignalName.TurnChanged, 1);
    }

    /// <summary>
    /// 记录球进袋（在球运动过程中调用）
    /// </summary>
    public void RecordPocketedBall(int ballNumber)
    {
        if (ballNumber == 0)
        {
            // 母球进袋 = 犯规
            _cueBallPocketed = true;
            GD.Print("犯规！母球进袋！");
            return;
        }

        _turnPocketedBalls.Add(ballNumber);
        GD.Print($"球 #{ballNumber} 进袋（本轮记录）");
    }

    /// <summary>
    /// 记录母球碰到的第一颗球
    /// </summary>
    public void RecordFirstContact(int ballNumber)
    {
        if (_cueBallHitValidBall) return; // 已经记录过了

        var currentPlayer = GetCurrentPlayer();

        if (currentPlayer.AssignedType == BallType.Unassigned)
        {
            // 未分色时，碰到任何目标球都算合法
            _cueBallHitValidBall = true;
        }
        else if (currentPlayer.CanShootEight)
        {
            // 该打8号球了，必须先碰到8号球
            _cueBallHitValidBall = (ballNumber == 8);
        }
        else
        {
            // 正常情况，必须先碰到自己花色的球
            bool isMyBall = (currentPlayer.AssignedType == BallType.Solid && ballNumber >= 1 && ballNumber <= 7)
                         || (currentPlayer.AssignedType == BallType.Stripe && ballNumber >= 9 && ballNumber <= 15);
            _cueBallHitValidBall = isMyBall;
        }

        if (!_cueBallHitValidBall)
        {
            GD.Print($"犯规！母球先碰到了不合法的球 #{ballNumber}");
        }
    }

    /// <summary>
    /// 判定回合结果（所有球停下后调用）
    /// </summary>
    public TurnResult JudgeTurn()
    {
        var currentPlayer = GetCurrentPlayer();
        var otherPlayer = GetOtherPlayer();

        // 检查犯规
        _turnFoul = false;
        string foulReason = "";

        if (_cueBallPocketed)
        {
            _turnFoul = true;
            foulReason = "母球进袋";
        }
        else if (!_cueBallHitValidBall && CurrentState != GameState.Breaking)
        {
            _turnFoul = true;
            foulReason = "未碰到合法的目标球";
        }

        // 检查是否打进了8号球
        if (_turnPocketedBalls.Contains(8))
        {
            if (currentPlayer.CanShootEight && !_turnFoul)
            {
                // 合法打进8号球 → 赢了！
                GD.Print($"玩家{currentPlayer.PlayerId} 获胜！合法打进8号球！");
                CurrentState = GameState.GameOver;
                EmitSignal(SignalName.StateChanged, GameState.GameOver);
                EmitSignal(SignalName.GameOver, currentPlayer.PlayerId, "合法打进8号球");
                return TurnResult.Win;
            }
            else
            {
                // 非法打进8号球 → 输了！
                GD.Print($"玩家{currentPlayer.PlayerId} 失败！非法打进8号球！");
                CurrentState = GameState.GameOver;
                EmitSignal(SignalName.StateChanged, GameState.GameOver);
                EmitSignal(SignalName.GameOver, otherPlayer.PlayerId, "对手非法打进8号球");
                return TurnResult.Lose;
            }
        }

        // 处理犯规
        if (_turnFoul)
        {
            GD.Print($"犯规！原因: {foulReason}");
            SwitchPlayer();
            CurrentState = GameState.PlacingCueBall;
            EmitSignal(SignalName.StateChanged, GameState.PlacingCueBall);
            EmitSignal(SignalName.TurnResult, TurnResult.Foul, $"犯规: {foulReason}，对手获得自由球");
            _ResetTurnData();
            return TurnResult.Foul;
        }

        // 处理进球
        bool pocketedOwnBall = false;

        foreach (int ballNum in _turnPocketedBalls)
        {
            if (!IsTypeAssigned)
            {
                // 第一次有效进球，分配花色
                AssignBallTypes(ballNum);
                IsTypeAssigned = true;
            }

            // 记录进球到对应玩家
            var ballType = GetBallType(ballNum);
            if (ballType == BallType.Solid || ballType == BallType.Stripe)
            {
                if (currentPlayer.AssignedType == ballType)
                {
                    currentPlayer.PocketedBalls.Add(ballNum);
                    pocketedOwnBall = true;
                    GD.Print($"玩家{currentPlayer.PlayerId} 打进了自己的球 #{ballNum}");

                    // 检查是否打完了所有球
                    if (currentPlayer.RemainingBalls == 0)
                    {
                        currentPlayer.CanShootEight = true;
                        GD.Print($"玩家{currentPlayer.PlayerId} 打完了所有球，可以打8号球了！");
                    }
                }
                else
                {
                    otherPlayer.PocketedBalls.Add(ballNum);
                    GD.Print($"玩家{currentPlayer.PlayerId} 打进了对方的球 #{ballNum}");
                }
            }
        }

        // 从开球状态切换到正常游戏
        if (CurrentState == GameState.Breaking)
        {
            CurrentState = GameState.Playing;
            EmitSignal(SignalName.StateChanged, GameState.Playing);
        }

        // 判定回合结果
        if (pocketedOwnBall)
        {
            GD.Print($"玩家{currentPlayer.PlayerId} 继续回合");
            EmitSignal(SignalName.TurnResult, TurnResult.Continue, "打进了自己的球，继续！");
            _ResetTurnData();
            return TurnResult.Continue;
        }
        else
        {
            GD.Print($"换人");
            SwitchPlayer();
            EmitSignal(SignalName.TurnResult, TurnResult.SwitchPlayer, $"换玩家{CurrentPlayerId}");
            _ResetTurnData();
            return TurnResult.SwitchPlayer;
        }
    }

    /// <summary>
    /// 分配花色
    /// </summary>
    private void AssignBallTypes(int firstPocketedBall)
    {
        var type = GetBallType(firstPocketedBall);

        if (type == BallType.Solid)
        {
            GetCurrentPlayer().AssignedType = BallType.Solid;
            GetOtherPlayer().AssignedType = BallType.Stripe;
        }
        else if (type == BallType.Stripe)
        {
            GetCurrentPlayer().AssignedType = BallType.Stripe;
            GetOtherPlayer().AssignedType = BallType.Solid;
        }
        else
        {
            // 如果第一颗进的是8号球（不太可能但需要处理）
            GetCurrentPlayer().AssignedType = BallType.Solid;
            GetOtherPlayer().AssignedType = BallType.Stripe;
        }

        GD.Print($"花色分配: 玩家1={Player1.AssignedType}, 玩家2={Player2.AssignedType}");
    }

    /// <summary>
    /// 获取球的花色类型
    /// </summary>
    private BallType GetBallType(int ballNumber)
    {
        return ballNumber switch
        {
            0 => BallType.Unassigned,
            >= 1 and <= 7 => BallType.Solid,
            8 => BallType.EightBall,
            >= 9 and <= 15 => BallType.Stripe,
            _ => BallType.Unassigned
        };
    }

    /// <summary>
    /// 切换玩家
    /// </summary>
    private void SwitchPlayer()
    {
        CurrentPlayerId = (CurrentPlayerId == 1) ? 2 : 1;
        GD.Print($"切换到玩家{CurrentPlayerId}");
        EmitSignal(SignalName.TurnChanged, CurrentPlayerId);
    }

    /// <summary>
    /// 获取当前玩家
    /// </summary>
    public PlayerData GetCurrentPlayer()
    {
        return CurrentPlayerId == 1 ? Player1 : Player2;
    }

    /// <summary>
    /// 获取另一位玩家
    /// </summary>
    public PlayerData GetOtherPlayer()
    {
        return CurrentPlayerId == 1 ? Player2 : Player1;
    }

    /// <summary>
    /// 重置回合数据
    /// </summary>
    private void _ResetTurnData()
    {
        _turnPocketedBalls.Clear();
        _turnFoul = false;
        _cueBallHitValidBall = false;
        _cueBallPocketed = false;
    }

    /// <summary>
    /// 放置母球完成（自由球放置后调用）
    /// </summary>
    public void OnCueBallPlaced()
    {
        if (CurrentState == GameState.PlacingCueBall)
        {
            CurrentState = GameState.Playing;
            EmitSignal(SignalName.StateChanged, GameState.Playing);
            GD.Print("母球放置完成，继续游戏");
        }
    }
}

6.6 自由球放置

犯规后，对手获得自由球，可以把母球放在球桌上的任意位置。

放置规则

规则说明
放置范围球桌内部任意位置
不能重叠母球不能和其他球重叠
不能出界母球必须在球桌范围内
确认放置点击桌面确认位置

自由球是很大的优势

获得自由球的玩家可以把母球放在最有利的位置，比如正对目标球和球袋的直线上。所以一定要避免犯规！

6.7 犯规判定汇总

犯规类型检测方式处罚
母球进袋球袋Area3D检测到母球对方自由球
未碰到球碰撞记录为空对方自由球
先碰错球第一次碰撞对象不对对方自由球
球飞出桌外球位置超出球桌边界对方自由球

6.8 胜负判定

条件结果说明
打完7球后合法打进8号球获胜正常获胜
未打完7球就打进8号球判负提前打进8号球
犯规时打进8号球判负犯规+8号球
8号球飞出球桌判负8号球出界

6.9 小结

在本章中，我们实现了完整的游戏规则系统：

  1. 球种类定义：纯色球、花色球、8号球的分类
  2. 开球排列：三角形排列的计算和规则
  3. 玩家数据：存储每位玩家的花色、进球列表等
  4. 规则管理器：判定回合结果、犯规、胜负
  5. 自由球：犯规后的母球放置逻辑
  6. 犯规检测：母球进袋、未碰球、先碰错球

规则系统让桌球从一个"物理模拟器"变成了一个"完整的游戏"。有了规则，玩家才能知道该谁打、打了之后会发生什么、什么时候赢。

→ 7. 摄像机视角与2.5D呈现

最近更新:
贡献者: zefeng.peng,bobokaka
EVOCOSMOS
Copyright © 2026 EVOCOSMOS