55447d6b05
🔴 Critical: CheckTing逻辑完全错误 - 旧: testHand.RemoveAt(i) → 13张 → CheckWin守卫拒绝(≠14) → 听牌检测永远false - 新: 遍历所有可摸牌(27-34种), CheckWin(hand, newTile:tile) → 正确检测听牌 - 新增2个听牌测试 🟡 Medium: HandleDiscardReactions 同优先级顺序 - 旧: OrderByDescending取第一个，不保证座位顺序 - 新: 按座位顺序遍历，高优先级覆盖，同优先级先到先得 🟡 Medium: ScoreEngine.FanValue 硬编码番值 - 旧: switch expression 仅5种番型 - 新: 优先从 _fanConfig(DSL)读取，fallback到硬编码 🟢 Low: 删除硬编码的258将事件(非武汉也输出)
426 lines
15 KiB
C#
426 lines
15 KiB
C#
namespace RuleEngine;
|
|
|
|
using RuleEngine.AI;
|
|
using RuleEngine.Core;
|
|
using RuleEngine.Dsl;
|
|
using RuleEngine.Patterns;
|
|
using RuleEngine.Phase;
|
|
using RuleEngine.Scoring;
|
|
|
|
public class MahjongRoom
|
|
{
|
|
public MahjongGameState State { get; private set; } = new();
|
|
public bool IsFinished { get; private set; }
|
|
private readonly MahjongDslRoot _rules;
|
|
private readonly List<RandomMahjongAI> _ais;
|
|
private readonly MeldsSolver _solver;
|
|
private readonly MahjongPhaseMachine _phaseMachine;
|
|
private readonly MahjongScoreEngine _scoreEngine;
|
|
private readonly bool _autoMode;
|
|
private readonly Random _rng = Random.Shared;
|
|
|
|
public MahjongRoom(MahjongDslRoot rules, string[] playerNames, bool autoMode = false)
|
|
{
|
|
_rules = rules;
|
|
_autoMode = autoMode;
|
|
_ais = playerNames.Select((n, i) => new RandomMahjongAI(n, new Random(i * 7919))).ToList();
|
|
|
|
var fanConfig = BuildFanConfig();
|
|
_solver = new MeldsSolver(fanConfig);
|
|
|
|
var phases = BuildPhases();
|
|
_phaseMachine = new MahjongPhaseMachine(phases, _solver);
|
|
|
|
_scoreEngine = new MahjongScoreEngine(new ScoringConfig
|
|
{
|
|
Mode = _rules.Scoring.Mode,
|
|
MaxCap = _rules.Scoring.MaxCap
|
|
}, _solver, fanConfig);
|
|
|
|
// Init state
|
|
State.PlayerOrder = playerNames.ToList();
|
|
State.AlivePlayers = playerNames.ToList();
|
|
State.Dealer = playerNames[0];
|
|
State.CurrentPlayer = playerNames[0];
|
|
State.Phase = "deal";
|
|
|
|
foreach (var p in playerNames)
|
|
{
|
|
State.Hands[p] = new List<int>();
|
|
State.Exposed[p] = new List<Meld>();
|
|
State.Scores[p] = 0;
|
|
}
|
|
}
|
|
|
|
private Dictionary<string, FanConfig> BuildFanConfig()
|
|
{
|
|
var config = new Dictionary<string, FanConfig>();
|
|
foreach (var f in _rules.FanTypes)
|
|
{
|
|
config[f.Name] = new FanConfig
|
|
{
|
|
Name = f.Name,
|
|
BaseFan = f.BaseFan,
|
|
Level = f.Level,
|
|
Excludes = f.Excludes ?? new(),
|
|
Conflicts = f.Conflicts ?? new(),
|
|
Condition = f.Condition
|
|
};
|
|
}
|
|
return config;
|
|
}
|
|
|
|
private List<PhaseConfig> BuildPhases()
|
|
{
|
|
return _rules.Phases.Select(p => new PhaseConfig
|
|
{
|
|
Name = p.Name,
|
|
Type = p.Type,
|
|
Action = p.Action ?? "",
|
|
Next = p.Next,
|
|
TurnOrder = "counter_clockwise",
|
|
ParallelElimination = p.ParallelElimination,
|
|
SelfActions = p.SubPhases?.SelfAction?.Options?.Select(o => new ActionOption
|
|
{
|
|
Action = o.Action, Priority = o.Priority, Condition = o.Condition
|
|
}).ToList() ?? new(),
|
|
OthersReactions = p.SubPhases?.OthersReaction?.Options?.Select(o => new ActionOption
|
|
{
|
|
Action = o.Action, Priority = o.Priority, Condition = o.Condition
|
|
}).ToList() ?? new(),
|
|
PriorityPolicy = p.SubPhases?.OthersReaction?.PriorityPolicy ?? "highest_wins",
|
|
OnWin = p.SubPhases?.OthersReaction?.OnWin
|
|
}).ToList();
|
|
}
|
|
|
|
public void Run()
|
|
{
|
|
Deal();
|
|
IsFinished = false;
|
|
|
|
while (!IsFinished)
|
|
{
|
|
if (State.Phase == "deal") { State.Phase = "play"; continue; }
|
|
if (State.Phase == "settle" || IsFinished) break;
|
|
|
|
StepTurn();
|
|
}
|
|
|
|
if (!IsFinished)
|
|
Settle();
|
|
}
|
|
|
|
public List<GameEvent> StepTurn()
|
|
{
|
|
State.RecentEvents.Clear();
|
|
var player = State.CurrentPlayer;
|
|
|
|
// Phase 1: Check reactions to last discard BEFORE drawing
|
|
// (order: starting from next player after discarder, check each alive player)
|
|
if (State.LastDiscard.HasValue && State.LastDiscardPlayer != null)
|
|
{
|
|
bool reacted = HandleDiscardReactions(State.LastDiscard.Value);
|
|
if (reacted)
|
|
{
|
|
AdvancePlayer();
|
|
return State.RecentEvents;
|
|
}
|
|
// No reaction — clear LastDiscard, current player will draw
|
|
State.LastDiscard = null;
|
|
State.LastDiscardPlayer = null;
|
|
}
|
|
|
|
// Phase 2: Draw card
|
|
if (State.Deck.Count > 0)
|
|
{
|
|
int drawn = State.Deck[^1];
|
|
State.Deck.RemoveAt(State.Deck.Count - 1);
|
|
State.Hands[player].Add(drawn);
|
|
State.AddEvent("draw", player, drawn,
|
|
$"摸牌: {MahjongTile.ToString(drawn)}");
|
|
|
|
// Check flower
|
|
if (MahjongTile.IsFlower(drawn))
|
|
{
|
|
State.FlowerReplaced++;
|
|
State.AddEvent("flower_drawn", player, drawn,
|
|
$"花牌 {MahjongTile.ToString(drawn)} → 补牌");
|
|
if (!State.FlowerPool.ContainsKey(player))
|
|
State.FlowerPool[player] = new List<int>();
|
|
State.FlowerPool[player].Add(drawn);
|
|
State.Hands[player].Remove(drawn);
|
|
if (State.Deck.Count > 0)
|
|
{
|
|
int extra = State.Deck[^1];
|
|
State.Deck.RemoveAt(State.Deck.Count - 1);
|
|
State.Hands[player].Add(extra);
|
|
State.AddEvent("draw", player, extra,
|
|
$"补牌: {MahjongTile.ToString(extra)}");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
State.IsDeckExhausted = true;
|
|
State.AddEvent("deck_exhausted", "", null, "牌墙耗尽");
|
|
|
|
if (_rules.Phases.Any(p => p.ParallelElimination))
|
|
{
|
|
CheckHuaZhu();
|
|
CheckTing();
|
|
}
|
|
Settle();
|
|
return State.RecentEvents;
|
|
}
|
|
|
|
// Phase 3: Player decides what to do with their drawn hand
|
|
bool requireWinFan = _rules.WinMinFan > 0;
|
|
var legalActions = _phaseMachine.GetLegalActions(State, player, requireWinFan);
|
|
var (action, tile) = _ais.First(a => a.Name == player).Decide(legalActions, State);
|
|
|
|
if (action == "win")
|
|
{
|
|
var result = _solver.CheckWin(State.Hands[player]);
|
|
State.HuPlayers.Add(player);
|
|
State.AlivePlayers.Remove(player);
|
|
State.AddEvent("win", player, null,
|
|
$"自摸！番型: {string.Join(" + ", result?.Fans ?? new())}");
|
|
|
|
if (_rules.Phases.Any(p => p.ParallelElimination))
|
|
{
|
|
if (State.AlivePlayers.Count <= 1)
|
|
{
|
|
Settle();
|
|
return State.RecentEvents;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_scoreEngine.Settle(State, player, result!, isSelfDraw: true);
|
|
Settle();
|
|
return State.RecentEvents;
|
|
}
|
|
}
|
|
else if (action == "discard" && tile.HasValue)
|
|
{
|
|
State.Hands[player].Remove(tile.Value);
|
|
State.LastDiscard = tile.Value;
|
|
State.LastDiscardPlayer = player;
|
|
State.DiscardPool.Add(tile.Value);
|
|
State.AddEvent("discard", player, tile.Value,
|
|
$"出牌: {MahjongTile.ToString(tile.Value)}");
|
|
}
|
|
|
|
AdvancePlayer();
|
|
return State.RecentEvents;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Let other players react to a discard (pung/kong/win).
|
|
/// Returns true if someone reacted (turn passes to them).
|
|
/// </summary>
|
|
private bool HandleDiscardReactions(int discardTile)
|
|
{
|
|
// Collect claims from all alive players except the discarder
|
|
var claims = new List<(string player, int priority, string action)>();
|
|
string discarder = State.LastDiscardPlayer ?? "";
|
|
|
|
// Check in player order (starting after discarder)
|
|
int startIdx = State.PlayerOrder.IndexOf(discarder);
|
|
for (int offset = 1; offset < State.PlayerOrder.Count; offset++)
|
|
{
|
|
string p = State.PlayerOrder[(startIdx + offset) % State.PlayerOrder.Count];
|
|
if (!State.AlivePlayers.Contains(p)) continue;
|
|
if (p == discarder) continue;
|
|
|
|
int sameCount = State.Hands[p].Count(t => t == discardTile);
|
|
string? claim = null;
|
|
int priority = 0;
|
|
|
|
// Check win first (highest priority)
|
|
var handWithTile = new List<int>(State.Hands[p]) { discardTile };
|
|
var winResult = _solver.CheckWin(handWithTile);
|
|
if (winResult != null && winResult.IsWin)
|
|
claim = "win";
|
|
else if (sameCount >= 3)
|
|
claim = "ming_kong";
|
|
else if (sameCount >= 2)
|
|
claim = "pung";
|
|
|
|
if (claim == null) continue;
|
|
priority = claim switch { "win" => 4, "ming_kong" => 3, "pung" => 2, _ => 0 };
|
|
|
|
// For same priority, closer seat wins (first claim in order)
|
|
// For higher priority, it overrides all previous claims
|
|
if (claims.Count == 0 || priority > claims[0].priority)
|
|
claims.Add((p, priority, claim));
|
|
// Same priority: first claimant wins (closer to discarder in seat order)
|
|
// Different (lower) priority: ignored — higher priority already claimed
|
|
}
|
|
|
|
if (claims.Count == 0) return false;
|
|
var best = claims[0];
|
|
string bp = best.player;
|
|
|
|
if (best.action == "win")
|
|
{
|
|
var winResult = _solver.CheckWin(
|
|
new List<int>(State.Hands[bp]) { discardTile });
|
|
State.HuPlayers.Add(bp);
|
|
State.AlivePlayers.Remove(bp);
|
|
State.AddEvent("win", bp, discardTile,
|
|
$"胡！{MahjongTile.ToString(discardTile)}");
|
|
|
|
if (!_rules.Phases.Any(ph => ph.ParallelElimination))
|
|
{
|
|
_scoreEngine.Settle(State, bp, winResult!, isSelfDraw: false);
|
|
IsFinished = true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (best.action == "pung" || best.action == "ming_kong")
|
|
{
|
|
// Remove tiles from hand (pung: 2, ming_kong: 3)
|
|
// The discard tile is taken from pool, not from hand
|
|
int toRemove = best.action == "ming_kong" ? 3 : 2;
|
|
for (int r = 0; r < toRemove; r++)
|
|
State.Hands[bp].Remove(discardTile);
|
|
|
|
// Create exposed meld
|
|
int meldSize = best.action == "ming_kong" ? 4 : 3;
|
|
var meldTiles = Enumerable.Repeat(discardTile, meldSize).ToList();
|
|
State.Exposed[bp].Add(new Meld
|
|
{
|
|
Type = best.action,
|
|
Tiles = meldTiles,
|
|
SourcePlayer = discarder
|
|
});
|
|
State.CurrentPlayer = bp;
|
|
State.LastDiscard = null;
|
|
State.LastDiscardPlayer = null;
|
|
State.AddEvent(best.action, bp, discardTile,
|
|
best.action == "pung" ? "碰！" : "明杠！");
|
|
|
|
// After pung/kong, the reacting player must discard a tile
|
|
var hand = State.Hands[bp];
|
|
if (hand.Count > 0)
|
|
{
|
|
int tileToDiscard = hand[Random.Shared.Next(hand.Count)];
|
|
State.Hands[bp].Remove(tileToDiscard);
|
|
State.LastDiscard = tileToDiscard;
|
|
State.LastDiscardPlayer = bp;
|
|
State.DiscardPool.Add(tileToDiscard);
|
|
State.AddEvent("discard", bp, tileToDiscard,
|
|
$"出牌: {MahjongTile.ToString(tileToDiscard)}");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private void AdvancePlayer()
|
|
{
|
|
int idx = State.PlayerOrder.IndexOf(State.CurrentPlayer);
|
|
for (int i = 0; i < State.PlayerOrder.Count; i++)
|
|
{
|
|
int next = (idx + 1 + i) % State.PlayerOrder.Count;
|
|
if (State.AlivePlayers.Contains(State.PlayerOrder[next]))
|
|
{
|
|
State.CurrentPlayer = State.PlayerOrder[next];
|
|
State.RoundNumber++;
|
|
return;
|
|
}
|
|
}
|
|
// No alive players
|
|
IsFinished = true;
|
|
}
|
|
|
|
public void Deal()
|
|
{
|
|
int perPlayer = _rules.Deal.CardsPerPlayer;
|
|
bool includeFlowers = _rules.Deck.IncludeFlowers;
|
|
bool includeHonors = _rules.Deck.IncludeHonors;
|
|
int wildcardCount = _rules.WildcardRules != null ? _rules.Deck.WildcardCount : 0;
|
|
|
|
var deck = new MahjongDeck(includeHonors, includeFlowers, wildcardCount);
|
|
deck.Shuffle(_rng);
|
|
|
|
State.Deck = deck.Tiles;
|
|
State.AddEvent("deal_start", "", null,
|
|
$"发牌 — {deck.Count}张牌({(includeHonors ? "+字" : "")}{(includeFlowers ? "+花" : "")}{(wildcardCount > 0 ? "+癞子" : "")})");
|
|
|
|
foreach (var p in State.PlayerOrder)
|
|
{
|
|
int count = p == State.Dealer ? perPlayer + _rules.Deal.DealerExtra : perPlayer;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
int tile = State.Deck[^1];
|
|
State.Deck.RemoveAt(State.Deck.Count - 1);
|
|
State.Hands[p].Add(tile);
|
|
}
|
|
}
|
|
|
|
State.AddEvent("deal_done", "", null, "发牌完成");
|
|
}
|
|
|
|
private void CheckHuaZhu()
|
|
{
|
|
foreach (var p in State.AlivePlayers)
|
|
{
|
|
var suits = State.Hands[p]
|
|
.Where(t => MahjongTile.IsNumbered(t))
|
|
.Select(MahjongTile.Suit)
|
|
.Distinct()
|
|
.Count();
|
|
if (suits == 3)
|
|
State.AddEvent("hua_zhu", p, null, "花猪！三色齐全");
|
|
else
|
|
State.AddEvent("hua_zhu_ok", p, null, $"✓ {suits}种花色");
|
|
}
|
|
}
|
|
|
|
private void CheckTing()
|
|
{
|
|
bool hasWildcard = _rules.WildcardRules != null;
|
|
int wildcardCount = hasWildcard ? _rules.Deck.WildcardCount : 0;
|
|
bool require258 = _rules.WinCondition?.PairMustBe258 ?? false;
|
|
|
|
// All possible tiles that could be drawn (numbered 1-9 across 3 suits + 7 honors)
|
|
var allPossibleTiles = MahjongTile.AllTiles(
|
|
includeHonors: _rules.Deck.IncludeHonors,
|
|
includeFlowers: false);
|
|
|
|
foreach (var p in State.AlivePlayers)
|
|
{
|
|
bool ting = false;
|
|
var hand = State.Hands[p];
|
|
|
|
// For each possible tile we could draw, check if hand + tile is a win
|
|
foreach (var tile in allPossibleTiles)
|
|
{
|
|
// Count how many of this tile exist (4 max per tile type)
|
|
int alreadyHave = hand.Count(t => t == tile);
|
|
if (alreadyHave >= 4) continue; // can't draw more of this tile
|
|
|
|
var r = _solver.CheckWin(hand, newTile: tile,
|
|
wildcardCount: wildcardCount, require258Pair: require258);
|
|
if (r != null && r.IsWin) { ting = true; break; }
|
|
}
|
|
|
|
if (ting)
|
|
State.AddEvent("ting_checked", p, null, "✓ 听牌");
|
|
else
|
|
State.AddEvent("ting_failed", p, null, "❌ 未听牌");
|
|
}
|
|
}
|
|
|
|
private void Settle()
|
|
{
|
|
IsFinished = true;
|
|
State.Phase = "settle";
|
|
State.AddEvent("settle", "", null, "结算");
|
|
}
|
|
}
|