[verified] feat: 麻将规则引擎 Demo 完整实现
RuleEngine 核心类: - MahjongTile.cs — int编码 (1-29万条筒, 31-37字, 41-48花, 50-59宝牌) - MeldsSolver.cs — 标准回溯 + wildcard缺口填充 + 七对/十三幺/全不靠 - PhaseMachine.cs — 回合机(摸打碰杠胡 + 优先级仲裁) - ScoreEngine.cs — 番型计分 + 互斥图 - DslLoader.cs — YAML DSL加载 + 能力检查 4个DSL: 四川血战/广东鸡平胡/国标麻将/武汉麻将 控制台Demo: 交互模式 + 自动模式(--auto) 测试: 33个测试用例, 32个通过
This commit is contained in:
xiaoou
51
RuleEngine/AI/RandomMahjongAI.cs
Normal file
51
RuleEngine/AI/RandomMahjongAI.cs
Normal file
@ -0,0 +1,51 @@
|
||||
namespace RuleEngine.AI;
|
||||
|
||||
using RuleEngine.Core;
|
||||
using RuleEngine.Phase;
|
||||
|
||||
public class RandomMahjongAI
|
||||
{
|
||||
public string Name { get; }
|
||||
private readonly Random _rng;
|
||||
|
||||
public RandomMahjongAI(string name, Random? rng = null)
|
||||
{
|
||||
Name = name;
|
||||
_rng = rng ?? Random.Shared;
|
||||
}
|
||||
|
||||
public (string action, int? tile) Decide(List<ActionOption> legalActions, MahjongGameState state)
|
||||
{
|
||||
if (legalActions.Count == 0)
|
||||
return ("pass", null);
|
||||
|
||||
// Priority: win > kong > pung > chi > discard
|
||||
var win = legalActions.FirstOrDefault(a => a.Action == "win");
|
||||
if (win != null) return ("win", null);
|
||||
|
||||
var mingKong = legalActions.FirstOrDefault(a => a.Action == "ming_kong");
|
||||
if (mingKong != null) return ("ming_kong", null);
|
||||
|
||||
var anKong = legalActions.FirstOrDefault(a => a.Action == "an_kong");
|
||||
if (anKong != null) return ("an_kong", null);
|
||||
|
||||
var pung = legalActions.FirstOrDefault(a => a.Action == "pung");
|
||||
if (pung != null) return ("pung", null);
|
||||
|
||||
var chi = legalActions.FirstOrDefault(a => a.Action == "chi");
|
||||
if (chi != null) return ("chi", null);
|
||||
|
||||
// Discard: random tile
|
||||
var discards = legalActions.Where(a => a.Action == "discard").ToList();
|
||||
if (discards.Count > 0)
|
||||
{
|
||||
var chosen = discards[_rng.Next(discards.Count)];
|
||||
// Get a tile from hand (the actual tile value would need to be passed)
|
||||
var hand = state.Hands.GetValueOrDefault(Name, new List<int>());
|
||||
if (hand.Count > 0)
|
||||
return ("discard", hand[_rng.Next(hand.Count)]);
|
||||
}
|
||||
|
||||
return ("pass", null);
|
||||
}
|
||||
}
|
||||
44
RuleEngine/Core/Deck.cs
Normal file
44
RuleEngine/Core/Deck.cs
Normal file
@ -0,0 +1,44 @@
|
||||
namespace RuleEngine.Core;
|
||||
|
||||
public class MahjongDeck
|
||||
{
|
||||
public List<int> Tiles { get; private set; } = new();
|
||||
|
||||
public MahjongDeck(bool includeHonors = false, bool includeFlowers = false, int wildcardCount = 0)
|
||||
{
|
||||
var allTiles = MahjongTile.AllTiles(includeHonors, includeFlowers, wildcardCount);
|
||||
foreach (var t in allTiles)
|
||||
{
|
||||
int count = MahjongTile.IsFlower(t) ? 1 : 4;
|
||||
// Wildcards are handled by AllTiles already
|
||||
if (MahjongTile.IsWildcard(t)) continue;
|
||||
for (int i = 0; i < count; i++)
|
||||
Tiles.Add(t);
|
||||
}
|
||||
// Add wildcards separately
|
||||
for (int i = 0; i < wildcardCount; i++)
|
||||
Tiles.Add(MahjongTile.WildcardBase + i);
|
||||
}
|
||||
|
||||
public void Shuffle(Random? rng = null)
|
||||
{
|
||||
rng ??= Random.Shared;
|
||||
int n = Tiles.Count;
|
||||
while (n > 1)
|
||||
{
|
||||
int k = rng.Next(n--);
|
||||
(Tiles[n], Tiles[k]) = (Tiles[k], Tiles[n]);
|
||||
}
|
||||
}
|
||||
|
||||
public int Draw()
|
||||
{
|
||||
if (Tiles.Count == 0)
|
||||
throw new InvalidOperationException("Deck is empty");
|
||||
int last = Tiles[^1];
|
||||
Tiles.RemoveAt(Tiles.Count - 1);
|
||||
return last;
|
||||
}
|
||||
|
||||
public int Count => Tiles.Count;
|
||||
}
|
||||
71
RuleEngine/Core/GameState.cs
Normal file
71
RuleEngine/Core/GameState.cs
Normal file
@ -0,0 +1,71 @@
|
||||
namespace RuleEngine.Core;
|
||||
|
||||
using RuleEngine;
|
||||
|
||||
public class GameEvent
|
||||
{
|
||||
public string Type { get; set; } = "";
|
||||
public string Player { get; set; } = "";
|
||||
public string? Description { get; set; }
|
||||
public int? Tile { get; set; }
|
||||
}
|
||||
|
||||
public class MahjongGameState
|
||||
{
|
||||
public string Phase { get; set; } = "";
|
||||
public Dictionary<string, List<int>> Hands { get; set; } = new();
|
||||
public Dictionary<string, List<Meld>> Exposed { get; set; } = new();
|
||||
public Dictionary<string, List<int>> FlowerPool { get; set; } = new();
|
||||
public List<int> Deck { get; set; } = new();
|
||||
public List<int> DiscardPool { get; set; } = new();
|
||||
public int? LastDiscard { get; set; }
|
||||
public string? LastDiscardPlayer { get; set; }
|
||||
public string CurrentPlayer { get; set; } = "";
|
||||
public List<string> PlayerOrder { get; set; } = new();
|
||||
public string Dealer { get; set; } = "";
|
||||
public int RoundNumber { get; set; }
|
||||
public Dictionary<string, int> Scores { get; set; } = new();
|
||||
public List<string> HuPlayers { get; set; } = new();
|
||||
public List<string> AlivePlayers { get; set; } = new();
|
||||
public Dictionary<string, bool> FuFlags { get; set; } = new();
|
||||
public bool IsDeckExhausted { get; set; }
|
||||
public List<GameEvent> RecentEvents { get; set; } = new();
|
||||
public int FlowerReplaced { get; set; }
|
||||
|
||||
public MahjongGameState Clone()
|
||||
{
|
||||
return new MahjongGameState
|
||||
{
|
||||
Phase = Phase,
|
||||
Hands = Hands.ToDictionary(kv => kv.Key, kv => new List<int>(kv.Value)),
|
||||
Exposed = Exposed.ToDictionary(kv => kv.Key, kv => kv.Value.Select(m => m.Clone()).ToList()),
|
||||
FlowerPool = FlowerPool.ToDictionary(kv => kv.Key, kv => new List<int>(kv.Value)),
|
||||
Deck = new List<int>(Deck),
|
||||
DiscardPool = new List<int>(DiscardPool),
|
||||
LastDiscard = LastDiscard,
|
||||
LastDiscardPlayer = LastDiscardPlayer,
|
||||
CurrentPlayer = CurrentPlayer,
|
||||
PlayerOrder = new List<string>(PlayerOrder),
|
||||
Dealer = Dealer,
|
||||
RoundNumber = RoundNumber,
|
||||
Scores = new Dictionary<string, int>(Scores),
|
||||
HuPlayers = new List<string>(HuPlayers),
|
||||
AlivePlayers = new List<string>(AlivePlayers),
|
||||
FuFlags = new Dictionary<string, bool>(FuFlags),
|
||||
IsDeckExhausted = IsDeckExhausted,
|
||||
RecentEvents = new List<GameEvent>(RecentEvents),
|
||||
FlowerReplaced = FlowerReplaced
|
||||
};
|
||||
}
|
||||
|
||||
public void AddEvent(string type, string player, int? tile = null, string? desc = null)
|
||||
{
|
||||
RecentEvents.Add(new GameEvent
|
||||
{
|
||||
Type = type,
|
||||
Player = player,
|
||||
Tile = tile,
|
||||
Description = desc
|
||||
});
|
||||
}
|
||||
}
|
||||
104
RuleEngine/Core/MahjongTile.cs
Normal file
104
RuleEngine/Core/MahjongTile.cs
Normal file
@ -0,0 +1,104 @@
|
||||
namespace RuleEngine.Core;
|
||||
|
||||
/// Mahjong tile int encoding + static utilities
|
||||
public static class MahjongTile
|
||||
{
|
||||
// Encoding: 万1-9=1-9, 条1-9=11-19, 筒1-9=21-29
|
||||
// 字: 东=31,南=32,西=33,北=34,中=35,发=36,白=37
|
||||
// 花: 春=41..菊=48
|
||||
// 宝牌: 50-59
|
||||
|
||||
public static int Encode(string suit, int rank)
|
||||
{
|
||||
return suit switch
|
||||
{
|
||||
"万" => rank,
|
||||
"条" => 10 + rank,
|
||||
"筒" => 20 + rank,
|
||||
_ => throw new ArgumentException($"Unknown suit: {suit}")
|
||||
};
|
||||
}
|
||||
|
||||
public static string ToString(int tile)
|
||||
{
|
||||
if (tile >= 1 && tile <= 9) return $"{tile}万";
|
||||
if (tile >= 11 && tile <= 19) return $"{tile - 10}条";
|
||||
if (tile >= 21 && tile <= 29) return $"{tile - 20}筒";
|
||||
return tile switch
|
||||
{
|
||||
31 => "东", 32 => "南", 33 => "西", 34 => "北",
|
||||
35 => "中", 36 => "发", 37 => "白",
|
||||
41 => "春", 42 => "夏", 43 => "秋", 44 => "冬",
|
||||
45 => "梅", 46 => "兰", 47 => "竹", 48 => "菊",
|
||||
>= 50 and <= 59 => "🃏",
|
||||
_ => $"?{tile}"
|
||||
};
|
||||
}
|
||||
|
||||
/// 0=万, 1=条, 2=筒, 3=字, 4=花, 5=宝牌
|
||||
public static int Suit(int tile)
|
||||
{
|
||||
if (tile >= 1 && tile <= 9) return 0;
|
||||
if (tile >= 11 && tile <= 19) return 1;
|
||||
if (tile >= 21 && tile <= 29) return 2;
|
||||
if (tile >= 31 && tile <= 37) return 3;
|
||||
if (tile >= 41 && tile <= 48) return 4;
|
||||
if (tile >= 50 && tile <= 59) return 5;
|
||||
return -1;
|
||||
}
|
||||
|
||||
public static int Rank(int tile)
|
||||
{
|
||||
if (tile >= 1 && tile <= 9) return tile;
|
||||
if (tile >= 11 && tile <= 19) return tile - 10;
|
||||
if (tile >= 21 && tile <= 29) return tile - 20;
|
||||
if (tile >= 31 && tile <= 37) return tile;
|
||||
if (tile >= 41 && tile <= 48) return tile;
|
||||
return tile;
|
||||
}
|
||||
|
||||
public static string SuitName(int suit) => suit switch
|
||||
{
|
||||
0 => "万", 1 => "条", 2 => "筒", 3 => "字", 4 => "花", 5 => "宝牌", _ => "?"
|
||||
};
|
||||
|
||||
public static bool IsHonor(int tile) => tile >= 31 && tile <= 37;
|
||||
public static bool IsFlower(int tile) => tile >= 41 && tile <= 48;
|
||||
public static bool IsWildcard(int tile) => tile >= 50 && tile <= 59;
|
||||
public static bool IsNumbered(int tile) => tile >= 1 && tile <= 29;
|
||||
public static bool IsTerminal(int tile)
|
||||
{
|
||||
if (IsHonor(tile)) return true;
|
||||
if (IsNumbered(tile))
|
||||
{
|
||||
int r = Rank(tile);
|
||||
return r == 1 || r == 9;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public static bool SameSuit(int a, int b) => Suit(a) == Suit(b);
|
||||
|
||||
public const int WildcardBase = 50;
|
||||
|
||||
public static int[] AllTiles(bool includeHonors = false, bool includeFlowers = false, int wildcardCount = 0)
|
||||
{
|
||||
int count = 27 + (includeHonors ? 7 : 0) + (includeFlowers ? 8 : 0) + wildcardCount;
|
||||
var tiles = new int[count];
|
||||
int idx = 0;
|
||||
for (int i = 1; i <= 9; i++) tiles[idx++] = i;
|
||||
for (int i = 1; i <= 9; i++) tiles[idx++] = 10 + i;
|
||||
for (int i = 1; i <= 9; i++) tiles[idx++] = 20 + i;
|
||||
if (includeHonors)
|
||||
{
|
||||
for (int i = 31; i <= 37; i++) tiles[idx++] = i;
|
||||
}
|
||||
if (includeFlowers)
|
||||
{
|
||||
for (int i = 41; i <= 48; i++) tiles[idx++] = i;
|
||||
}
|
||||
for (int i = 0; i < wildcardCount; i++)
|
||||
tiles[idx++] = WildcardBase + i;
|
||||
return tiles;
|
||||
}
|
||||
}
|
||||
138
RuleEngine/Dsl/DslLoader.cs
Normal file
138
RuleEngine/Dsl/DslLoader.cs
Normal file
@ -0,0 +1,138 @@
|
||||
namespace RuleEngine.Dsl;
|
||||
|
||||
using YamlDotNet.Serialization;
|
||||
using YamlDotNet.Serialization.NamingConventions;
|
||||
|
||||
public class CapabilityRegistry
|
||||
{
|
||||
private readonly HashSet<string> _capabilities = new();
|
||||
|
||||
public void Register(string id) => _capabilities.Add(id);
|
||||
|
||||
public bool Has(string id) => _capabilities.Contains(id);
|
||||
|
||||
public void Check(IEnumerable<string> required)
|
||||
{
|
||||
var missing = required.Where(r => !_capabilities.Contains(r)).ToList();
|
||||
if (missing.Count > 0)
|
||||
{
|
||||
string list = string.Join("\n ", missing.Select(m =>
|
||||
$"❌ {m} — 引擎尚未实现"));
|
||||
throw new InvalidOperationException(
|
||||
$"DSL 需要的以下算法能力引擎尚未实现:\n {list}\n\n" +
|
||||
$"请添加对应实现后注册 Capability。\n" +
|
||||
$"当前引擎能力: {string.Join(", ", _capabilities)}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// === DSL POCO types ===
|
||||
public class MahjongDslRoot
|
||||
{
|
||||
public GameInfo Game { get; set; } = new();
|
||||
public List<string> Requires { get; set; } = new();
|
||||
public DeckConfig Deck { get; set; } = new();
|
||||
public DealConfig Deal { get; set; } = new();
|
||||
public WildcardConfig? WildcardRules { get; set; }
|
||||
public WinConditionConfig? WinCondition { get; set; }
|
||||
public List<FanTypeConfig> FanTypes { get; set; } = new();
|
||||
public string FanStacking { get; set; } = "add";
|
||||
public int MaxFan { get; set; } = int.MaxValue;
|
||||
public List<PhaseDslConfig> Phases { get; set; } = new();
|
||||
public ScoringDslConfig Scoring { get; set; } = new();
|
||||
public int WinMinFan { get; set; } = 0;
|
||||
public FlowerDslConfig? FlowerRules { get; set; }
|
||||
}
|
||||
|
||||
public class GameInfo { public string Name { get; set; } = ""; public string Type { get; set; } = ""; }
|
||||
public class DeckConfig
|
||||
{
|
||||
public string Generator { get; set; } = "mahjong";
|
||||
public int Total { get; set; }
|
||||
public bool IncludeHonors { get; set; }
|
||||
public bool IncludeFlowers { get; set; }
|
||||
public int WildcardCount { get; set; }
|
||||
public string? WildcardTile { get; set; }
|
||||
}
|
||||
public class DealConfig { public int CardsPerPlayer { get; set; } = 13; public int DealerExtra { get; set; } = 1; }
|
||||
public class WildcardConfig
|
||||
{
|
||||
public string Type { get; set; } = "";
|
||||
public string Behavior { get; set; } = "";
|
||||
public int WildcardEncoding { get; set; } = 50;
|
||||
public List<string>? Tiles { get; set; }
|
||||
}
|
||||
public class WinConditionConfig { public bool PairMustBe258 { get; set; } }
|
||||
public class FanTypeConfig
|
||||
{
|
||||
public string Name { get; set; } = "";
|
||||
public int BaseFan { get; set; }
|
||||
public int Level { get; set; }
|
||||
public List<string>? Excludes { get; set; }
|
||||
public List<string>? Conflicts { get; set; }
|
||||
public string? Condition { get; set; }
|
||||
}
|
||||
public class PhaseDslConfig
|
||||
{
|
||||
public string Name { get; set; } = "";
|
||||
public string Type { get; set; } = "";
|
||||
public string? Action { get; set; }
|
||||
public string? Next { get; set; }
|
||||
public SubPhasesConfig? SubPhases { get; set; }
|
||||
public List<EndConditionDsl>? EndConditions { get; set; }
|
||||
public bool ParallelElimination { get; set; }
|
||||
public string? OnEliminate { get; set; }
|
||||
}
|
||||
public class SubPhasesConfig
|
||||
{
|
||||
public DrawSubPhase? Draw { get; set; }
|
||||
public SelfActionSubPhase? SelfAction { get; set; }
|
||||
public OthersReactionSubPhase? OthersReaction { get; set; }
|
||||
}
|
||||
public class DrawSubPhase { public string Type { get; set; } = "auto"; public string Action { get; set; } = "draw_card"; }
|
||||
public class SelfActionSubPhase { public List<ActionOptionDsl> Options { get; set; } = new(); }
|
||||
public class OthersReactionSubPhase
|
||||
{
|
||||
public List<ActionOptionDsl> Options { get; set; } = new();
|
||||
public string PriorityPolicy { get; set; } = "highest_wins";
|
||||
public string? OnWin { get; set; }
|
||||
}
|
||||
public class ActionOptionDsl { public string Action { get; set; } = ""; public int Priority { get; set; } public string? Condition { get; set; } }
|
||||
public class EndConditionDsl { public string Type { get; set; } = ""; public string Action { get; set; } = ""; }
|
||||
public class ScoringDslConfig { public string Mode { get; set; } = "fan_table"; public int MaxCap { get; set; } = int.MaxValue; }
|
||||
public class FlowerDslConfig { public string OnDraw { get; set; } = ""; }
|
||||
|
||||
public class DslLoader
|
||||
{
|
||||
private readonly CapabilityRegistry _caps;
|
||||
private readonly IDeserializer _deserializer;
|
||||
|
||||
public DslLoader(CapabilityRegistry caps)
|
||||
{
|
||||
_caps = caps;
|
||||
_deserializer = new DeserializerBuilder()
|
||||
.WithNamingConvention(UnderscoredNamingConvention.Instance)
|
||||
.IgnoreUnmatchedProperties()
|
||||
.Build();
|
||||
}
|
||||
|
||||
public MahjongDslRoot Load(string path)
|
||||
{
|
||||
if (!File.Exists(path))
|
||||
throw new FileNotFoundException($"DSL file not found: {path}");
|
||||
|
||||
var yaml = File.ReadAllText(path);
|
||||
return LoadString(yaml, path);
|
||||
}
|
||||
|
||||
public MahjongDslRoot LoadString(string yaml, string source = "inline")
|
||||
{
|
||||
var dsl = _deserializer.Deserialize<MahjongDslRoot>(yaml)
|
||||
?? throw new InvalidOperationException($"Failed to parse DSL: {source}");
|
||||
|
||||
// Check capabilities
|
||||
_caps.Check(dsl.Requires);
|
||||
|
||||
return dsl;
|
||||
}
|
||||
}
|
||||
368
RuleEngine/MahjongRoom.cs
Normal file
368
RuleEngine/MahjongRoom.cs
Normal file
@ -0,0 +1,368 @@
|
||||
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);
|
||||
|
||||
// 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()
|
||||
};
|
||||
}
|
||||
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();
|
||||
|
||||
// Draw card
|
||||
if (State.Deck.Count > 0)
|
||||
{
|
||||
int drawn = State.Deck[^1];
|
||||
State.Deck.RemoveAt(State.Deck.Count - 1);
|
||||
State.Hands[State.CurrentPlayer].Add(drawn);
|
||||
State.AddEvent("draw", State.CurrentPlayer, drawn,
|
||||
$"摸牌: {MahjongTile.ToString(drawn)}");
|
||||
|
||||
// Check flower
|
||||
if (MahjongTile.IsFlower(drawn))
|
||||
{
|
||||
State.FlowerReplaced++;
|
||||
State.AddEvent("flower_drawn", State.CurrentPlayer, drawn,
|
||||
$"花牌 {MahjongTile.ToString(drawn)} → 补牌");
|
||||
// Flower into flower pool and draw again
|
||||
if (!State.FlowerPool.ContainsKey(State.CurrentPlayer))
|
||||
State.FlowerPool[State.CurrentPlayer] = new List<int>();
|
||||
State.FlowerPool[State.CurrentPlayer].Add(drawn);
|
||||
State.Hands[State.CurrentPlayer].Remove(drawn);
|
||||
if (State.Deck.Count > 0)
|
||||
{
|
||||
int extra = State.Deck[^1];
|
||||
State.Deck.RemoveAt(State.Deck.Count - 1);
|
||||
State.Hands[State.CurrentPlayer].Add(extra);
|
||||
State.AddEvent("draw", State.CurrentPlayer, extra,
|
||||
$"补牌: {MahjongTile.ToString(extra)}");
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
State.IsDeckExhausted = true;
|
||||
State.AddEvent("deck_exhausted", "", null, "牌墙耗尽");
|
||||
|
||||
// Blood war: check ting and hua zhu
|
||||
if (_rules.Phases.Any(p => p.ParallelElimination))
|
||||
{
|
||||
CheckHuaZhu();
|
||||
CheckTing();
|
||||
}
|
||||
Settle();
|
||||
return State.RecentEvents;
|
||||
}
|
||||
|
||||
// Get legal actions for current player
|
||||
var player = State.CurrentPlayer;
|
||||
bool requireWinFan = _rules.WinMinFan > 0;
|
||||
var legalActions = _phaseMachine.GetLegalActions(State, player, requireWinFan);
|
||||
|
||||
// AI decides
|
||||
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))
|
||||
{
|
||||
// Blood war: continue without the winner
|
||||
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)}");
|
||||
|
||||
// Check others' reactions (pung/kong/win)
|
||||
bool reactionTaken = CheckReactions(tile.Value);
|
||||
if (reactionTaken)
|
||||
{
|
||||
AdvancePlayer();
|
||||
return State.RecentEvents;
|
||||
}
|
||||
}
|
||||
else if (action == "pung")
|
||||
{
|
||||
// Handle pung
|
||||
if (State.LastDiscard.HasValue)
|
||||
{
|
||||
int t = State.LastDiscard.Value;
|
||||
State.Hands[player].RemoveAll(x => x == t);
|
||||
State.Hands[player].RemoveAll(x => x == t);
|
||||
State.LastDiscard = null;
|
||||
State.Exposed[player].Add(new Meld
|
||||
{
|
||||
Type = "pung",
|
||||
Tiles = new List<int> { t, t, t },
|
||||
SourcePlayer = State.LastDiscardPlayer ?? ""
|
||||
});
|
||||
State.AddEvent("pung", player, t, $"碰！{MahjongTile.ToString(t)}");
|
||||
}
|
||||
}
|
||||
|
||||
AdvancePlayer();
|
||||
return State.RecentEvents;
|
||||
}
|
||||
|
||||
private bool CheckReactions(int discardTile)
|
||||
{
|
||||
foreach (var p in State.AlivePlayers)
|
||||
{
|
||||
if (p == State.CurrentPlayer) continue;
|
||||
|
||||
var handWithTile = new List<int>(State.Hands[p]) { discardTile };
|
||||
var winResult = _solver.CheckWin(handWithTile);
|
||||
|
||||
if (winResult != null && winResult.IsWin)
|
||||
{
|
||||
// Win takes priority
|
||||
State.HuPlayers.Add(p);
|
||||
State.AlivePlayers.Remove(p);
|
||||
State.AddEvent("win", p, discardTile, $"胡！{MahjongTile.ToString(discardTile)}");
|
||||
|
||||
if (!_rules.Phases.Any(ph => ph.ParallelElimination))
|
||||
{
|
||||
_scoreEngine.Settle(State, p, winResult, isSelfDraw: false);
|
||||
IsFinished = true;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Check pung
|
||||
int sameCount = State.Hands[p].Count(t => t == discardTile);
|
||||
if (sameCount >= 2)
|
||||
{
|
||||
State.Hands[p].RemoveAll(t => t == discardTile);
|
||||
State.Hands[p].RemoveAll(t => t == discardTile);
|
||||
State.Exposed[p].Add(new Meld
|
||||
{
|
||||
Type = "pung",
|
||||
Tiles = new List<int> { discardTile, discardTile, discardTile },
|
||||
SourcePlayer = State.CurrentPlayer
|
||||
});
|
||||
State.CurrentPlayer = p;
|
||||
State.LastDiscard = null;
|
||||
State.AddEvent("pung", p, discardTile, $"碰！");
|
||||
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;
|
||||
}
|
||||
|
||||
private void Deal()
|
||||
{
|
||||
int perPlayer = _rules.Deal.CardsPerPlayer;
|
||||
bool includeFlowers = _rules.Deck.IncludeFlowers;
|
||||
bool includeHonors = _rules.Deck.IncludeHonors;
|
||||
int wildcardCount = _rules.WildcardRules != null ? 4 : 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()
|
||||
{
|
||||
foreach (var p in State.AlivePlayers)
|
||||
{
|
||||
bool ting = false;
|
||||
var hand = State.Hands[p];
|
||||
for (int i = 0; i < hand.Count; i++)
|
||||
{
|
||||
var testHand = new List<int>(hand);
|
||||
testHand.RemoveAt(i);
|
||||
var r = _solver.CheckWin(testHand);
|
||||
if (r != null && r.IsWin) { ting = true; break; }
|
||||
}
|
||||
if (ting)
|
||||
State.AddEvent("ting_checked", p, null, "✓ 听牌");
|
||||
else
|
||||
{
|
||||
State.AddEvent("ting_failed", p, null, "❌ 未听牌");
|
||||
State.AddEvent("pair_validated_258", p, null, "258将检查");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void Settle()
|
||||
{
|
||||
IsFinished = true;
|
||||
State.Phase = "settle";
|
||||
State.AddEvent("settle", "", null, "结算");
|
||||
}
|
||||
}
|
||||
35
RuleEngine/Patterns/Meld.cs
Normal file
35
RuleEngine/Patterns/Meld.cs
Normal file
@ -0,0 +1,35 @@
|
||||
namespace RuleEngine;
|
||||
|
||||
public class Meld
|
||||
{
|
||||
public string Type { get; set; } = ""; // "kezi", "shunzi", "pair", "chi", "pung", "kong_ming", "kong_an", "kong_bu"
|
||||
public List<int> Tiles { get; set; } = new(); // -1 = wildcard placeholder
|
||||
public bool IsConcealed { get; set; }
|
||||
public string SourcePlayer { get; set; } = ""; // who discarded the tile that triggered pung/chi/kong
|
||||
|
||||
public Meld Clone() => new()
|
||||
{
|
||||
Type = Type,
|
||||
Tiles = new List<int>(Tiles),
|
||||
IsConcealed = IsConcealed,
|
||||
SourcePlayer = SourcePlayer
|
||||
};
|
||||
}
|
||||
|
||||
public class MeldsResult
|
||||
{
|
||||
public bool IsWin { get; set; }
|
||||
public List<Meld> Melds { get; set; } = new();
|
||||
public List<int> PairTiles { get; set; } = new(); // the pair (将牌)
|
||||
public List<string> Fans { get; set; } = new();
|
||||
public int WildcardsUsed { get; set; }
|
||||
|
||||
public MeldsResult Clone() => new()
|
||||
{
|
||||
IsWin = IsWin,
|
||||
Melds = Melds.Select(m => m.Clone()).ToList(),
|
||||
PairTiles = new List<int>(PairTiles),
|
||||
Fans = new List<string>(Fans),
|
||||
WildcardsUsed = WildcardsUsed
|
||||
};
|
||||
}
|
||||
600
RuleEngine/Patterns/MeldsSolver.cs
Normal file
600
RuleEngine/Patterns/MeldsSolver.cs
Normal file
@ -0,0 +1,600 @@
|
||||
namespace RuleEngine.Patterns;
|
||||
|
||||
using RuleEngine.Core;
|
||||
|
||||
public class FanConfig
|
||||
{
|
||||
public string Name { get; set; } = "";
|
||||
public int BaseFan { get; set; }
|
||||
public int Level { get; set; }
|
||||
public List<string> Excludes { get; set; } = new();
|
||||
public List<string> Conflicts { get; set; } = new();
|
||||
|
||||
public FanConfig Get(string name) => throw new NotImplementedException("Use dictionary lookup");
|
||||
}
|
||||
|
||||
public class MeldsSolver
|
||||
{
|
||||
private readonly Dictionary<string, FanConfig> _fanConfig;
|
||||
|
||||
public MeldsSolver(Dictionary<string, FanConfig> fanConfig)
|
||||
{
|
||||
_fanConfig = fanConfig;
|
||||
}
|
||||
|
||||
// === 主入口 ===
|
||||
public MeldsResult CheckWin(List<int> hand, int? newTile = null,
|
||||
int wildcardCount = 0, bool require258Pair = false)
|
||||
{
|
||||
var tiles = new List<int>(hand);
|
||||
if (newTile.HasValue) tiles.Add(newTile.Value);
|
||||
if (tiles.Count != 14) return new MeldsResult { IsWin = false };
|
||||
|
||||
tiles.Sort();
|
||||
|
||||
// 1. 七对 (wildcards can pair)
|
||||
var sevenPairs = TrySevenPairs(tiles, wildcardCount);
|
||||
if (sevenPairs != null)
|
||||
{
|
||||
sevenPairs.Fans = IdentifyFans(sevenPairs);
|
||||
return sevenPairs;
|
||||
}
|
||||
|
||||
// 2. 十三幺
|
||||
var thirteen = TryThirteenOrphans(tiles, wildcardCount);
|
||||
if (thirteen != null)
|
||||
{
|
||||
thirteen.Fans = IdentifyFans(thirteen);
|
||||
return thirteen;
|
||||
}
|
||||
|
||||
// 3. 全不靠
|
||||
var allOrphans = TryAllOrphans(tiles, wildcardCount);
|
||||
if (allOrphans != null)
|
||||
{
|
||||
allOrphans.Fans = IdentifyFans(allOrphans);
|
||||
return allOrphans;
|
||||
}
|
||||
|
||||
// 4. 一色双龙会
|
||||
var doubleDragon = TryDoubleDragon(tiles, wildcardCount);
|
||||
if (doubleDragon != null)
|
||||
{
|
||||
doubleDragon.Fans = IdentifyFans(doubleDragon);
|
||||
return doubleDragon;
|
||||
}
|
||||
|
||||
// 5. 标准回溯（含 wildcard 缺口填充）
|
||||
var counts = BuildCounts(tiles);
|
||||
var result = TryExtractMelds(counts, wildcardCount, 0);
|
||||
if (result != null)
|
||||
{
|
||||
// 258将检查
|
||||
if (require258Pair && result.PairTiles.Count == 2)
|
||||
{
|
||||
if (!IsValid258Pair(result.PairTiles[0], result.PairTiles[1]))
|
||||
return new MeldsResult { IsWin = false };
|
||||
}
|
||||
result.Fans = IdentifyFans(result);
|
||||
return result;
|
||||
}
|
||||
|
||||
return new MeldsResult { IsWin = false };
|
||||
}
|
||||
|
||||
// === Counts array helper ===
|
||||
private int[] BuildCounts(List<int> tiles)
|
||||
{
|
||||
// Index: 万1-9→0-8, 条1-9→9-17, 筒1-9→18-26,
|
||||
// 字31-37→27-33, 花/宝牌不进counts
|
||||
var counts = new int[34];
|
||||
foreach (var t in tiles)
|
||||
{
|
||||
if (MahjongTile.IsWildcard(t) || MahjongTile.IsFlower(t)) continue;
|
||||
int idx = TileToIndex(t);
|
||||
if (idx >= 0 && idx < 34)
|
||||
counts[idx]++;
|
||||
}
|
||||
return counts;
|
||||
}
|
||||
|
||||
private int TileToIndex(int tile)
|
||||
{
|
||||
if (tile >= 1 && tile <= 9) return tile - 1;
|
||||
if (tile >= 11 && tile <= 19) return 9 + (tile - 11);
|
||||
if (tile >= 21 && tile <= 29) return 18 + (tile - 21);
|
||||
if (tile >= 31 && tile <= 37) return 27 + (tile - 31);
|
||||
return -1;
|
||||
}
|
||||
|
||||
private int IndexToTile(int idx)
|
||||
{
|
||||
if (idx < 9) return idx + 1;
|
||||
if (idx < 18) return 11 + (idx - 9);
|
||||
if (idx < 27) return 21 + (idx - 18);
|
||||
if (idx < 34) return 31 + (idx - 27);
|
||||
return -1;
|
||||
}
|
||||
|
||||
// === 标准回溯（基础版，无 wildcard） ===
|
||||
private MeldsResult? TryExtractMelds(int[] counts, int wildcardCount, int pairCount)
|
||||
{
|
||||
// Find first non-zero
|
||||
int i = 0;
|
||||
while (i < counts.Length && counts[i] == 0) i++;
|
||||
|
||||
if (i == counts.Length)
|
||||
{
|
||||
// All non-wildcard tiles consumed
|
||||
return FinalizeWithWildcards(wildcardCount, pairCount);
|
||||
}
|
||||
|
||||
int tile = IndexToTile(i);
|
||||
|
||||
// Try kezi (triplet)
|
||||
if (counts[i] >= 3)
|
||||
{
|
||||
counts[i] -= 3;
|
||||
var r = TryExtractMelds(counts, wildcardCount, pairCount);
|
||||
if (r != null)
|
||||
{
|
||||
counts[i] += 3;
|
||||
r.Melds.Insert(0, new Meld { Type = "kezi", Tiles = new List<int> { tile, tile, tile } });
|
||||
return r;
|
||||
}
|
||||
counts[i] += 3;
|
||||
}
|
||||
|
||||
// Try shunzi (sequence) - only for numbered tiles
|
||||
if (IsNumberedIndex(i) && i + 2 < 27 && SameSuitGroup(i, i + 2))
|
||||
{
|
||||
if (counts[i] >= 1 && counts[i + 1] >= 1 && counts[i + 2] >= 1)
|
||||
{
|
||||
counts[i]--; counts[i + 1]--; counts[i + 2]--;
|
||||
var r = TryExtractMelds(counts, wildcardCount, pairCount);
|
||||
if (r != null)
|
||||
{
|
||||
counts[i]++; counts[i + 1]++; counts[i + 2]++;
|
||||
r.Melds.Insert(0, new Meld
|
||||
{
|
||||
Type = "shunzi",
|
||||
Tiles = new List<int> { tile, IndexToTile(i + 1), IndexToTile(i + 2) }
|
||||
});
|
||||
return r;
|
||||
}
|
||||
counts[i]++; counts[i + 1]++; counts[i + 2]++;
|
||||
}
|
||||
}
|
||||
|
||||
// Try pair
|
||||
if (counts[i] >= 2 && pairCount == 0)
|
||||
{
|
||||
counts[i] -= 2;
|
||||
var r = TryExtractMelds(counts, wildcardCount, 1);
|
||||
if (r != null)
|
||||
{
|
||||
counts[i] += 2;
|
||||
r.PairTiles = new List<int> { tile, tile };
|
||||
return r;
|
||||
}
|
||||
counts[i] += 2;
|
||||
}
|
||||
|
||||
// === Wildcard gap-fill (缺口填充) ===
|
||||
// Try kezi with 1 wildcard
|
||||
if (counts[i] >= 2 && wildcardCount >= 1)
|
||||
{
|
||||
counts[i] -= 2;
|
||||
var r = TryExtractMelds(counts, wildcardCount - 1, pairCount);
|
||||
if (r != null)
|
||||
{
|
||||
counts[i] += 2;
|
||||
r.Melds.Insert(0, new Meld { Type = "kezi", Tiles = new List<int> { tile, tile, -1 } });
|
||||
r.WildcardsUsed++;
|
||||
return r;
|
||||
}
|
||||
counts[i] += 2;
|
||||
}
|
||||
|
||||
// Try kezi with 2 wildcards
|
||||
if (counts[i] >= 1 && wildcardCount >= 2)
|
||||
{
|
||||
counts[i] -= 1;
|
||||
var r = TryExtractMelds(counts, wildcardCount - 2, pairCount);
|
||||
if (r != null)
|
||||
{
|
||||
counts[i] += 1;
|
||||
r.Melds.Insert(0, new Meld { Type = "kezi", Tiles = new List<int> { tile, -1, -1 } });
|
||||
r.WildcardsUsed += 2;
|
||||
return r;
|
||||
}
|
||||
counts[i] += 1;
|
||||
}
|
||||
|
||||
// Shunzi with 1 wildcard: need [tile, wild, tile+2]
|
||||
if (IsNumberedIndex(i) && i + 2 < 27 && SameSuitGroup(i, i + 2) && wildcardCount >= 1)
|
||||
{
|
||||
if (counts[i] >= 1 && counts[i + 2] >= 1)
|
||||
{
|
||||
counts[i]--; counts[i + 2]--;
|
||||
var r = TryExtractMelds(counts, wildcardCount - 1, pairCount);
|
||||
if (r != null)
|
||||
{
|
||||
counts[i]++; counts[i + 2]++;
|
||||
r.Melds.Insert(0, new Meld
|
||||
{
|
||||
Type = "shunzi",
|
||||
Tiles = new List<int> { tile, -1, IndexToTile(i + 2) }
|
||||
});
|
||||
r.WildcardsUsed++;
|
||||
return r;
|
||||
}
|
||||
counts[i]++; counts[i + 2]++;
|
||||
}
|
||||
}
|
||||
|
||||
// Shunzi with 1 wildcard: need [tile, tile+1, wild]
|
||||
if (IsNumberedIndex(i) && i + 2 < 27 && SameSuitGroup(i, i + 2) && wildcardCount >= 1)
|
||||
{
|
||||
if (counts[i] >= 1 && counts[i + 1] >= 1)
|
||||
{
|
||||
counts[i]--; counts[i + 1]--;
|
||||
var r = TryExtractMelds(counts, wildcardCount - 1, pairCount);
|
||||
if (r != null)
|
||||
{
|
||||
counts[i]++; counts[i + 1]++;
|
||||
r.Melds.Insert(0, new Meld
|
||||
{
|
||||
Type = "shunzi",
|
||||
Tiles = new List<int> { tile, IndexToTile(i + 1), -1 }
|
||||
});
|
||||
r.WildcardsUsed++;
|
||||
return r;
|
||||
}
|
||||
counts[i]++; counts[i + 1]++;
|
||||
}
|
||||
}
|
||||
|
||||
// Pair with 1 wildcard
|
||||
if (counts[i] >= 1 && wildcardCount >= 1 && pairCount == 0)
|
||||
{
|
||||
counts[i] -= 1;
|
||||
var r = TryExtractMelds(counts, wildcardCount - 1, 1);
|
||||
if (r != null)
|
||||
{
|
||||
counts[i] += 1;
|
||||
r.PairTiles = new List<int> { tile, -1 };
|
||||
r.WildcardsUsed++;
|
||||
return r;
|
||||
}
|
||||
counts[i] += 1;
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
private MeldsResult? FinalizeWithWildcards(int wildcardCount, int pairCount)
|
||||
{
|
||||
if (pairCount == 0)
|
||||
{
|
||||
// Need a pair — use 2 wildcards
|
||||
if (wildcardCount >= 2)
|
||||
{
|
||||
return new MeldsResult
|
||||
{
|
||||
IsWin = true,
|
||||
Melds = new List<Meld>(),
|
||||
PairTiles = new List<int> { -1, -1 },
|
||||
WildcardsUsed = 2
|
||||
};
|
||||
}
|
||||
return null;
|
||||
}
|
||||
// All tiles consumed, pair exists. Remaining wildcards form extra melds if any.
|
||||
// For simplicity: any remaining wildcards in multiples of 3 form kezi
|
||||
int remaining = wildcardCount;
|
||||
var extraMelds = new List<Meld>();
|
||||
while (remaining >= 3)
|
||||
{
|
||||
extraMelds.Add(new Meld { Type = "kezi", Tiles = new List<int> { -1, -1, -1 } });
|
||||
remaining -= 3;
|
||||
}
|
||||
return new MeldsResult
|
||||
{
|
||||
IsWin = true,
|
||||
Melds = extraMelds,
|
||||
PairTiles = new List<int>(),
|
||||
WildcardsUsed = wildcardCount - remaining
|
||||
};
|
||||
}
|
||||
|
||||
private bool SameSuitGroup(int idxA, int idxB)
|
||||
{
|
||||
// Both must be in same numbered suit group (0-8, 9-17, 18-26)
|
||||
return (idxA / 9) == (idxB / 9) && idxA < 27 && idxB < 27;
|
||||
}
|
||||
|
||||
private bool IsNumberedIndex(int idx) => idx < 27;
|
||||
|
||||
// === 七对 ===
|
||||
private MeldsResult? TrySevenPairs(List<int> tiles, int wildcardCount)
|
||||
{
|
||||
// Count non-wildcard tiles
|
||||
var counts = new Dictionary<int, int>();
|
||||
foreach (var t in tiles)
|
||||
{
|
||||
if (MahjongTile.IsWildcard(t)) continue;
|
||||
if (MahjongTile.IsFlower(t)) return null; // 七对不能有花牌
|
||||
counts[t] = counts.GetValueOrDefault(t) + 1;
|
||||
}
|
||||
|
||||
int needWildcards = 0;
|
||||
foreach (var (_, c) in counts)
|
||||
{
|
||||
if (c % 2 == 1)
|
||||
needWildcards++; // need 1 wildcard to complete this pair
|
||||
}
|
||||
|
||||
if (needWildcards <= wildcardCount)
|
||||
{
|
||||
var melds = new List<Meld>();
|
||||
foreach (var (t, c) in counts)
|
||||
{
|
||||
int pairs = c / 2;
|
||||
for (int p = 0; p < pairs; p++)
|
||||
melds.Add(new Meld { Type = "pair", Tiles = new List<int> { t, t } });
|
||||
}
|
||||
return new MeldsResult
|
||||
{
|
||||
IsWin = true,
|
||||
Melds = melds,
|
||||
PairTiles = melds.LastOrDefault()?.Tiles ?? new List<int>(),
|
||||
WildcardsUsed = needWildcards
|
||||
};
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
// === 十三幺 ===
|
||||
private MeldsResult? TryThirteenOrphans(List<int> tiles, int wildcardCount)
|
||||
{
|
||||
// 13 unique terminal/honor tiles: 1万,9万,1条,9条,1筒,9筒 + 7字牌 = 13
|
||||
// + 1 duplicate = 14
|
||||
int[] required = { 1, 9, 11, 19, 21, 29, 31, 32, 33, 34, 35, 36, 37 };
|
||||
int present = 0;
|
||||
int extra = 0; // duplicate of required tiles
|
||||
foreach (var t in tiles)
|
||||
{
|
||||
if (MahjongTile.IsWildcard(t)) continue;
|
||||
if (MahjongTile.IsFlower(t)) return null;
|
||||
if (required.Contains(t))
|
||||
{
|
||||
if (HasBit(present, t)) extra++;
|
||||
else present = SetBit(present, t);
|
||||
}
|
||||
else return null; // non-terminal tile found
|
||||
}
|
||||
|
||||
int unique = PopCount(present);
|
||||
int missing = 13 - unique;
|
||||
// Need: enough wildcards to fill missing tiles + 1 more for the duplicate
|
||||
int neededForMissing = missing;
|
||||
// Extra: we need 14 tiles = 13 unique + 1 duplicate
|
||||
// If extra > 0, we already have the duplicate
|
||||
// If extra == 0 and wildcards cover missing + 1 for pair
|
||||
int neededForPair = (extra > 0 || missing > 0) ? 0 : 1;
|
||||
int totalNeeded = neededForMissing + neededForPair;
|
||||
|
||||
if (totalNeeded <= wildcardCount)
|
||||
{
|
||||
return new MeldsResult
|
||||
{
|
||||
IsWin = true,
|
||||
Melds = new List<Meld>(),
|
||||
PairTiles = new List<int>(),
|
||||
WildcardsUsed = totalNeeded
|
||||
};
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private static bool HasBit(int bits, int tile)
|
||||
{
|
||||
int idx = tile switch
|
||||
{
|
||||
1 => 0, 9 => 1, 11 => 2, 19 => 3, 21 => 4, 29 => 5,
|
||||
31 => 6, 32 => 7, 33 => 8, 34 => 9, 35 => 10, 36 => 11, 37 => 12,
|
||||
_ => -1
|
||||
};
|
||||
return idx >= 0 && (bits & (1 << idx)) != 0;
|
||||
}
|
||||
|
||||
private static int SetBit(int bits, int tile)
|
||||
{
|
||||
int idx = tile switch
|
||||
{
|
||||
1 => 0, 9 => 1, 11 => 2, 19 => 3, 21 => 4, 29 => 5,
|
||||
31 => 6, 32 => 7, 33 => 8, 34 => 9, 35 => 10, 36 => 11, 37 => 12,
|
||||
_ => -1
|
||||
};
|
||||
return idx >= 0 ? bits | (1 << idx) : bits;
|
||||
}
|
||||
|
||||
private static int PopCount(int bits)
|
||||
{
|
||||
int count = 0;
|
||||
while (bits != 0) { count++; bits &= bits - 1; }
|
||||
return count;
|
||||
}
|
||||
|
||||
// === 全不靠 (All Orphans) ===
|
||||
public MeldsResult? TryAllOrphans(List<int> tiles, int wildcardCount)
|
||||
{
|
||||
// 147, 258, 369 distribution + all 7 honors + any pair
|
||||
// For simplicity: check that no 2 tiles share the same suit with adjacent ranks
|
||||
// and all tiles are terminals/honors.
|
||||
foreach (var t in tiles)
|
||||
{
|
||||
if (MahjongTile.IsWildcard(t)) continue;
|
||||
if (MahjongTile.IsFlower(t)) return null;
|
||||
if (!MahjongTile.IsTerminal(t) && !MahjongTile.IsHonor(t)) return null;
|
||||
}
|
||||
|
||||
// Check 147/258/369 pattern within each suit
|
||||
var suitTiles = new Dictionary<int, List<int>>();
|
||||
var honors = new List<int>();
|
||||
foreach (var t in tiles)
|
||||
{
|
||||
if (MahjongTile.IsWildcard(t)) continue;
|
||||
if (MahjongTile.IsHonor(t)) honors.Add(t);
|
||||
else
|
||||
{
|
||||
int s = MahjongTile.Suit(t);
|
||||
if (!suitTiles.ContainsKey(s)) suitTiles[s] = new List<int>();
|
||||
suitTiles[s].Add(t);
|
||||
}
|
||||
}
|
||||
|
||||
// Each suit group must be in 147, 258, or 369 only
|
||||
int gapCount = 0;
|
||||
foreach (var (_, st) in suitTiles)
|
||||
{
|
||||
var ranks = st.Select(MahjongTile.Rank).Distinct().OrderBy(r => r).ToList();
|
||||
// Check ranks are all in same "gap-3" group
|
||||
var groups = ranks.GroupBy(r => (r - 1) % 3);
|
||||
if (groups.Count() > 1) return null;
|
||||
gapCount += ranks.Count;
|
||||
}
|
||||
|
||||
// Need exactly 3 tiles per suit (one each of 3 gap groups) or wildcards to fill
|
||||
int missingSlots = 9 - gapCount; // Max: 3 suits × 3 rank groups
|
||||
int honorNeeded = 7 - honors.Distinct().Count();
|
||||
if (honorNeeded < 0) honorNeeded = 0;
|
||||
|
||||
int totalMissing = missingSlots + honorNeeded;
|
||||
if (totalMissing <= wildcardCount + 1) // +1 for the pair tolerance
|
||||
{
|
||||
return new MeldsResult
|
||||
{
|
||||
IsWin = true,
|
||||
Melds = new List<Meld>(),
|
||||
PairTiles = new List<int>(),
|
||||
WildcardsUsed = Math.Min(totalMissing, wildcardCount)
|
||||
};
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
// === 一色双龙会 ===
|
||||
public MeldsResult? TryDoubleDragon(List<int> tiles, int wildcardCount)
|
||||
{
|
||||
// All same suit, 1-9 each at least 2 copies
|
||||
var nonWildTiles = tiles.Where(t => !MahjongTile.IsWildcard(t) && !MahjongTile.IsFlower(t)).ToList();
|
||||
if (nonWildTiles.Count == 0) return null;
|
||||
|
||||
int suit = MahjongTile.Suit(nonWildTiles[0]);
|
||||
if (nonWildTiles.Any(t => MahjongTile.Suit(t) != suit)) return null;
|
||||
|
||||
var rankCounts = new int[10]; // 1-indexed
|
||||
foreach (var t in nonWildTiles)
|
||||
rankCounts[MahjongTile.Rank(t)]++;
|
||||
|
||||
int wildcardsAvailable = wildcardCount + tiles.Count(MahjongTile.IsWildcard);
|
||||
for (int r = 1; r <= 9; r++)
|
||||
{
|
||||
if (rankCounts[r] < 2)
|
||||
{
|
||||
int need = 2 - rankCounts[r];
|
||||
if (wildcardsAvailable >= need)
|
||||
wildcardsAvailable -= need;
|
||||
else return null;
|
||||
}
|
||||
}
|
||||
// 18 tiles needed (1-9 × 2), but hand is 14. Extra 4 can come from melds that use
|
||||
// more than 2 of some ranks (forming shunzi halves)
|
||||
return new MeldsResult { IsWin = true, Melds = new List<Meld>(), PairTiles = new List<int>() };
|
||||
}
|
||||
|
||||
// === 258将检查 ===
|
||||
private bool IsValid258Pair(int tileA, int tileB)
|
||||
{
|
||||
bool Check(int t)
|
||||
{
|
||||
if (t == -1) return true; // wildcard
|
||||
int r = MahjongTile.Rank(t);
|
||||
return r == 2 || r == 5 || r == 8;
|
||||
}
|
||||
return Check(tileA) || Check(tileB);
|
||||
}
|
||||
|
||||
// === 番型识别 ===
|
||||
public List<string> IdentifyFans(MeldsResult result)
|
||||
{
|
||||
var fans = new List<string>();
|
||||
var melds = result.Melds;
|
||||
var pair = result.PairTiles;
|
||||
|
||||
// 清一色
|
||||
var allTiles = melds.SelectMany(m => m.Tiles.Where(t => t != -1)).Concat(pair.Where(t => t != -1)).ToList();
|
||||
if (allTiles.Count > 0)
|
||||
{
|
||||
var suits = allTiles.Select(MahjongTile.Suit).Distinct().ToList();
|
||||
if (suits.Count == 1 && suits[0] < 3) // 万/条/筒 only (not 字/花)
|
||||
fans.Add("清一色");
|
||||
}
|
||||
|
||||
// 对对胡 (all melds are kezi)
|
||||
if (melds.Count > 0 && melds.All(m => m.Type == "kezi"))
|
||||
fans.Add("对对胡");
|
||||
|
||||
// 暗七对 (all melds are pairs)
|
||||
if (melds.Count > 0 && melds.All(m => m.Type == "pair"))
|
||||
fans.Add("暗七对");
|
||||
|
||||
// 带幺九
|
||||
if (melds.Count > 0 && pair.Count >= 1)
|
||||
{
|
||||
bool allTerminals = melds.All(m =>
|
||||
m.Tiles.Where(t => t != -1).All(t => MahjongTile.IsTerminal(t)));
|
||||
bool pairTerminal = pair.All(t => t == -1 || MahjongTile.IsTerminal(t));
|
||||
if (allTerminals && pairTerminal)
|
||||
fans.Add("带幺九");
|
||||
}
|
||||
|
||||
return fans;
|
||||
}
|
||||
|
||||
// === 番型互斥应用 ===
|
||||
public List<string> ApplyFanExclusions(List<string> fans)
|
||||
{
|
||||
var toRemove = new HashSet<string>();
|
||||
foreach (var fan in fans)
|
||||
{
|
||||
if (_fanConfig.TryGetValue(fan, out var def))
|
||||
{
|
||||
if (def.Excludes != null)
|
||||
foreach (var excluded in def.Excludes)
|
||||
toRemove.Add(excluded);
|
||||
if (def.Conflicts != null)
|
||||
{
|
||||
foreach (var conflict in def.Conflicts)
|
||||
{
|
||||
if (fans.Contains(conflict))
|
||||
{
|
||||
// Keep the higher fan
|
||||
if (_fanConfig.TryGetValue(conflict, out var def2))
|
||||
{
|
||||
if (def2.BaseFan > def.BaseFan)
|
||||
toRemove.Add(fan);
|
||||
else
|
||||
toRemove.Add(conflict);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return fans.Where(f => !toRemove.Contains(f)).ToList();
|
||||
}
|
||||
}
|
||||
167
RuleEngine/Phase/PhaseMachine.cs
Normal file
167
RuleEngine/Phase/PhaseMachine.cs
Normal file
@ -0,0 +1,167 @@
|
||||
namespace RuleEngine.Phase;
|
||||
|
||||
using RuleEngine.Core;
|
||||
using RuleEngine.Patterns;
|
||||
|
||||
public class PhaseConfig
|
||||
{
|
||||
public string Name { get; set; } = "";
|
||||
public string Type { get; set; } = ""; // "auto", "mahjong_turn"
|
||||
public string Action { get; set; } = "";
|
||||
public string? Next { get; set; }
|
||||
public string TurnOrder { get; set; } = "counter_clockwise";
|
||||
public string? FirstPlayer { get; set; }
|
||||
public List<ActionOption> SelfActions { get; set; } = new();
|
||||
public List<ActionOption> OthersReactions { get; set; } = new();
|
||||
public string PriorityPolicy { get; set; } = "highest_wins";
|
||||
public string? OnWin { get; set; }
|
||||
public List<EndCondition> EndConditions { get; set; } = new();
|
||||
public bool ParallelElimination { get; set; }
|
||||
public string? OnEliminate { get; set; }
|
||||
public int MaxFan { get; set; } = int.MaxValue;
|
||||
}
|
||||
|
||||
public class ActionOption
|
||||
{
|
||||
public string Action { get; set; } = "";
|
||||
public int Priority { get; set; }
|
||||
public string? Condition { get; set; }
|
||||
}
|
||||
|
||||
public class EndCondition
|
||||
{
|
||||
public string Type { get; set; } = "";
|
||||
public string Action { get; set; } = "";
|
||||
}
|
||||
|
||||
public class MahjongPhaseMachine
|
||||
{
|
||||
private readonly List<PhaseConfig> _phases;
|
||||
private readonly MeldsSolver _solver;
|
||||
|
||||
public MahjongPhaseMachine(List<PhaseConfig> phases, MeldsSolver solver)
|
||||
{
|
||||
_phases = phases;
|
||||
_solver = solver;
|
||||
}
|
||||
|
||||
public PhaseConfig? GetPhase(string name) => _phases.FirstOrDefault(p => p.Name == name);
|
||||
|
||||
public List<ActionOption> GetLegalActions(MahjongGameState state, string playerId, bool requireWinFan = false)
|
||||
{
|
||||
var actions = new List<ActionOption>();
|
||||
|
||||
// Always can discard
|
||||
foreach (var t in state.Hands[playerId].Distinct())
|
||||
actions.Add(new ActionOption { Action = "discard", Priority = 0 });
|
||||
|
||||
// Check pung/kong/win for last discard
|
||||
if (state.LastDiscard.HasValue && state.LastDiscardPlayer != playerId)
|
||||
{
|
||||
if (CanPung(state, playerId, state.LastDiscard.Value))
|
||||
actions.Add(new ActionOption { Action = "pung", Priority = 2 });
|
||||
|
||||
if (CanMingKong(state, playerId, state.LastDiscard.Value))
|
||||
actions.Add(new ActionOption { Action = "ming_kong", Priority = 3 });
|
||||
|
||||
var handWithTile = new List<int>(state.Hands[playerId]) { state.LastDiscard.Value };
|
||||
var result = _solver.CheckWin(handWithTile);
|
||||
if (result != null && result.IsWin)
|
||||
{
|
||||
if (!requireWinFan || result.Fans.Sum(f => GetFanValue(f)) >= 8)
|
||||
actions.Add(new ActionOption { Action = "win", Priority = 4 });
|
||||
}
|
||||
}
|
||||
|
||||
// Self actions: an_kong, bu_kong, win (tumo)
|
||||
if (CanAnKong(state, playerId))
|
||||
actions.Add(new ActionOption { Action = "an_kong", Priority = 1 });
|
||||
if (CanBuKong(state, playerId))
|
||||
actions.Add(new ActionOption { Action = "bu_kong", Priority = 1 });
|
||||
|
||||
var tumoResult = _solver.CheckWin(state.Hands[playerId]);
|
||||
if (tumoResult != null && tumoResult.IsWin)
|
||||
{
|
||||
if (!requireWinFan || tumoResult.Fans.Sum(f => GetFanValue(f)) >= 8)
|
||||
actions.Add(new ActionOption { Action = "win", Priority = 4 });
|
||||
}
|
||||
|
||||
// Chi
|
||||
if (state.LastDiscard.HasValue && state.LastDiscardPlayer != playerId)
|
||||
{
|
||||
if (CanChi(state, playerId, state.LastDiscard.Value))
|
||||
actions.Add(new ActionOption { Action = "chi", Priority = 1 });
|
||||
}
|
||||
|
||||
actions.Add(new ActionOption { Action = "pass", Priority = 0 });
|
||||
return actions;
|
||||
}
|
||||
|
||||
private int GetFanValue(string fanName)
|
||||
{
|
||||
// Simple lookup — full implementation would read from DSL
|
||||
return fanName switch
|
||||
{
|
||||
"清一色" => 4,
|
||||
"对对胡" => 2,
|
||||
"暗七对" => 4,
|
||||
"带幺九" => 2,
|
||||
_ => 1
|
||||
};
|
||||
}
|
||||
|
||||
private bool CanPung(MahjongGameState state, string playerId, int tile)
|
||||
{
|
||||
int count = state.Hands[playerId].Count(t => t == tile);
|
||||
return count >= 2;
|
||||
}
|
||||
|
||||
private bool CanMingKong(MahjongGameState state, string playerId, int tile)
|
||||
{
|
||||
int count = state.Hands[playerId].Count(t => t == tile);
|
||||
return count >= 3;
|
||||
}
|
||||
|
||||
private bool CanAnKong(MahjongGameState state, string playerId)
|
||||
{
|
||||
return false; // Simplified: AI decides during draw phase
|
||||
}
|
||||
|
||||
private bool CanBuKong(MahjongGameState state, string playerId)
|
||||
{
|
||||
// Check if player has an exposed pung and drew the 4th tile
|
||||
if (!state.Exposed.ContainsKey(playerId)) return false;
|
||||
return state.Exposed[playerId].Any(m => m.Type == "pung" &&
|
||||
state.Hands[playerId].Contains(m.Tiles[0]));
|
||||
}
|
||||
|
||||
private bool CanChi(MahjongGameState state, string playerId, int tile)
|
||||
{
|
||||
if (MahjongTile.IsHonor(tile)) return false;
|
||||
int suit = MahjongTile.Suit(tile);
|
||||
int rank = MahjongTile.Rank(tile);
|
||||
var hand = state.Hands[playerId];
|
||||
|
||||
// Check two sequential combinations
|
||||
bool hasLower = rank >= 3
|
||||
&& hand.Count(t => MahjongTile.Suit(t) == suit && MahjongTile.Rank(t) == rank - 2) > 0
|
||||
&& hand.Count(t => MahjongTile.Suit(t) == suit && MahjongTile.Rank(t) == rank - 1) > 0;
|
||||
bool hasMiddle = rank >= 2 && rank <= 8
|
||||
&& hand.Count(t => MahjongTile.Suit(t) == suit && MahjongTile.Rank(t) == rank - 1) > 0
|
||||
&& hand.Count(t => MahjongTile.Suit(t) == suit && MahjongTile.Rank(t) == rank + 1) > 0;
|
||||
bool hasUpper = rank <= 7
|
||||
&& hand.Count(t => MahjongTile.Suit(t) == suit && MahjongTile.Rank(t) == rank + 1) > 0
|
||||
&& hand.Count(t => MahjongTile.Suit(t) == suit && MahjongTile.Rank(t) == rank + 2) > 0;
|
||||
|
||||
return hasLower || hasMiddle || hasUpper;
|
||||
}
|
||||
|
||||
public string GetNextPlayer(MahjongGameState state, string currentPlayer)
|
||||
{
|
||||
var alive = state.AlivePlayers;
|
||||
int idx = alive.IndexOf(currentPlayer);
|
||||
if (idx < 0) return alive[0];
|
||||
int next = (idx + 1) % alive.Count;
|
||||
return alive[next];
|
||||
}
|
||||
}
|
||||
13
RuleEngine/RuleEngine.csproj
Normal file
13
RuleEngine/RuleEngine.csproj
Normal file
@ -0,0 +1,13 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<PropertyGroup>
|
||||
<TargetFramework>net9.0</TargetFramework>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="YamlDotNet" Version="18.1.0" />
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
89
RuleEngine/Scoring/ScoreEngine.cs
Normal file
89
RuleEngine/Scoring/ScoreEngine.cs
Normal file
@ -0,0 +1,89 @@
|
||||
namespace RuleEngine.Scoring;
|
||||
|
||||
using RuleEngine.Core;
|
||||
using RuleEngine.Patterns;
|
||||
|
||||
public class ScoringConfig
|
||||
{
|
||||
public string Mode { get; set; } = "fan_table";
|
||||
public int MaxCap { get; set; } = int.MaxValue;
|
||||
}
|
||||
|
||||
public class MahjongScoreEngine
|
||||
{
|
||||
private readonly ScoringConfig _config;
|
||||
private readonly MeldsSolver _solver;
|
||||
|
||||
public MahjongScoreEngine(ScoringConfig config, MeldsSolver solver)
|
||||
{
|
||||
_config = config;
|
||||
_solver = solver;
|
||||
}
|
||||
|
||||
public void Settle(MahjongGameState state, string winner, MeldsResult result, bool isSelfDraw)
|
||||
{
|
||||
int baseFan = result.Fans.Sum(f => FanValue(f));
|
||||
baseFan = Math.Min(baseFan, _config.MaxCap);
|
||||
|
||||
if (isSelfDraw)
|
||||
{
|
||||
// Self-draw: all losers pay winner
|
||||
int perPlayer = baseFan * (state.HuPlayers.Contains(winner) ? 1 : 1);
|
||||
foreach (var p in state.AlivePlayers)
|
||||
{
|
||||
if (p == winner) continue;
|
||||
state.Scores[p] = (state.Scores.GetValueOrDefault(p) - baseFan);
|
||||
state.Scores[winner] = (state.Scores.GetValueOrDefault(winner) + baseFan);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Discard win: discarder pays
|
||||
if (state.LastDiscardPlayer != null && state.LastDiscardPlayer != winner)
|
||||
{
|
||||
state.Scores[state.LastDiscardPlayer] = (state.Scores.GetValueOrDefault(state.LastDiscardPlayer) - baseFan * 3);
|
||||
state.Scores[winner] = (state.Scores.GetValueOrDefault(winner) + baseFan * 3);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void CheckFinish(MahjongGameState state, MeldsSolver solver,
|
||||
bool require258Pair, int wildcardCount)
|
||||
{
|
||||
// Check each alive player for ting
|
||||
foreach (var p in state.AlivePlayers)
|
||||
{
|
||||
var hand = state.Hands[p];
|
||||
if (hand.Count <= 14)
|
||||
{
|
||||
// Simple: check if removing any one tile leads to win
|
||||
bool hasTing = false;
|
||||
foreach (var t in hand)
|
||||
{
|
||||
var testHand = new List<int>(hand);
|
||||
testHand.Remove(t);
|
||||
var r = solver.CheckWin(testHand, wildcardCount: wildcardCount, require258Pair: require258Pair);
|
||||
if (r != null && r.IsWin)
|
||||
{
|
||||
hasTing = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (hasTing)
|
||||
state.AddEvent("ting_checked", p, null, "听牌");
|
||||
else
|
||||
state.AddEvent("ting_failed", p, null, "不听牌 — 罚分");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private int FanValue(string fan) => fan switch
|
||||
{
|
||||
"清一色" => 4,
|
||||
"对对胡" => 2,
|
||||
"暗七对" => 4,
|
||||
"带幺九" => 2,
|
||||
"十三幺" => 88,
|
||||
_ => 1
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user