Update test_scoring.py

src/engine/scoring.py

@@ -1,52 +1,32 @@
-def calculate_score(fan: int, base_score: int, is_self_draw: bool, is_dealer: bool) -> dict:
+def calculate_score(fan: int, base_score: int, is_self_draw: bool) -> dict:
     """
-    根据规则计算得分。
+    根据成都麻将规则计算得分（不区分庄家和闲家）。
 
     参数:
     - fan: 总番数。
     - base_score: 底分。
     - is_self_draw: 是否为自摸。
-    - is_dealer: 是否为庄家。
 
     返回:
     - scores: 字典，包含赢家得分和输家扣分。
     """
-    # 翻倍计算基础分
+    # 计算总分
-    total_score = base_score * (2 ** fan)
+    multiplier = 2 ** fan  # 根据番数计算倍率
+    total_score = base_score * multiplier
 
     if is_self_draw:
-        # 自摸，其他三家平摊
+        # 自摸：三家平摊分数
-        if is_dealer:
+        per_loser_score = -total_score
-            # 庄家自摸：每家付单倍总分
+        winner_score = total_score * 3  # 总赢家得分
-            per_loser_score = -total_score
+        return {
-            winner_score = total_score * 3  # 三家支付的总和
+            "winner": winner_score,
-            return {
+            "loser": [per_loser_score] * 3
-                "winner": winner_score,
+        }
-                "loser": [per_loser_score] * 3
-            }
-        else:
-            # 闲家自摸：庄家付双倍，其他两家付单倍
-            dealer_loss = -total_score * 2
-            other_loss = -total_score
-            winner_score = -dealer_loss + 2 * -other_loss  # 庄家和两闲家支付总和
-            return {
-                "winner": winner_score,
-                "loser": [dealer_loss, other_loss, other_loss]
-            }
     else:
-        # 点炮，点炮者独付
+        # 点炮：点炮者独付
         loser_score = -total_score
         winner_score = total_score
-        if is_dealer:
+        return {
-            # 庄家点炮
+            "winner": winner_score,
-            return {
+            "loser": [loser_score, 0, 0]
-                "winner": winner_score,
+        }
-                "loser": [loser_score, 0, 0]
-            }
-        else:
-            # 闲家点炮
-            return {
-                "winner": winner_score,
-                "loser": [loser_score, 0, 0]
-            }
-

tests/test_scoring.py

@@ -1,72 +1,19 @@
+import pytest
 from src.engine.scoring import calculate_score
 
+@pytest.mark.parametrize("fan, is_self_draw, base_score, expected_scores", [
+    # 测试用例 1: 自摸，总番数 3
+    (3, True, 5, {"winner": 120, "loser": [-40, -40, -40]}),
 
-def test_dealer_self_draw():
+    # 测试用例 2: 点炮，总番数 2
-    """
+    (2, False, 5, {"winner": 20, "loser": [-20, 0, 0]}),
-    测试用例 1: 庄家自摸，总番数 3，底分 10
-    """
-    fan = 3
-    base_score = 10
-    is_self_draw = True
-    is_dealer = True
 
-    scores = calculate_score(fan, base_score, is_self_draw, is_dealer)
+    # 测试用例 3: 自摸，总番数 4
-    expected_scores = {"winner": 240, "loser": [-80, -80, -80]}
+    (4, True, 5, {"winner": 240, "loser": [-80, -80, -80]}),
-    assert scores == expected_scores, f"庄家自摸测试失败: {scores} != {expected_scores}"
 
-
+    # 测试用例 4: 点炮，总番数 1
-def test_non_dealer_point_win():
+    (1, False, 5, {"winner": 10, "loser": [-10, 0, 0]}),
-    """
+])
-    测试用例 2: 闲家点炮，总番数 2，底分 10
+def test_calculate_score(fan, is_self_draw, base_score, expected_scores):
-    """
+    scores = calculate_score(fan, base_score, is_self_draw)
-    fan = 2
+    assert scores == expected_scores, f"测试失败: {scores} != {expected_scores}"
-    base_score = 10
-    is_self_draw = False
-    is_dealer = False
-
-    scores = calculate_score(fan, base_score, is_self_draw, is_dealer)
-    expected_scores = {"winner": 40, "loser": [-40, 0, 0]}
-    assert scores == expected_scores, f"闲家点炮测试失败: {scores} != {expected_scores}"
-
-
-def test_non_dealer_self_draw():
-    """
-     测试用例 3: 闲家自摸，总番数 4，底分 10
-     """
-    fan = 4
-    base_score = 10
-    is_self_draw = True
-    is_dealer = False
-
-    scores = calculate_score(fan, base_score, is_self_draw, is_dealer)
-    expected_scores = {"winner": 160, "loser": [-80, -40, -40]}
-    assert scores == expected_scores, f"闲家自摸测试失败: {scores} != {expected_scores}"
-
-
-def test_dealer_point_win():
-    """
-    测试用例 4: 庄家点炮，总番数 1，底分 5
-    """
-    fan = 1
-    base_score = 5
-    is_self_draw = False
-    is_dealer = True
-
-    scores = calculate_score(fan, base_score, is_self_draw, is_dealer)
-    expected_scores = {"winner": 10, "loser": [-10, 0, 0]}
-    assert scores == expected_scores, f"庄家点炮测试失败: {scores} != {expected_scores}"
-
-
-if __name__ == "__main__":
-    # 单独执行测试
-    test_dealer_self_draw()
-    print("测试 1: 庄家自摸通过！")
-
-    test_non_dealer_point_win()
-    print("测试 2: 闲家点炮通过！")
-
-    test_non_dealer_self_draw()
-    print("测试 3: 闲家自摸通过！")
-
-    test_dealer_point_win()
-    print("测试 4: 庄家点炮通过！")