锄大地计分器：规则引擎与链上记分方案

M_2 = 2^n    （n = 剩余 2 的张数）

Loss = R × M_card(R) × 2^n × P

# config.py
EXCEL_FILE_PATH = "./play-2d.xlsx"
CARD_PRICE = 0.5
 
PLAYERS_CONFIG = {
    "A": "APlayer",
    "B": "BPlayer",
    "C": "CPlayer",
    "D": "DPlayer"
}
 
CARD_MULT_RULES = [
    (range(13, 14), 4),     # 剩 13 张 → ×4
    (range(10, 13), 3),     # 剩 10–12 张 → ×3
    (range(8, 10), 2),      # 剩 8–9 张 → ×2
    (range(0, 8), 1),       # 剩 0–7 张 → ×1
]
 
def get_card_mult(remain_cards: int) -> int:
    for condition, mult in CARD_MULT_RULES:
        if remain_cards in condition:
            return mult
    return 1
 
CARD_MULT = { element: get_card_mult(element) for element in range(1, 14) }
 
RULES_CONFIG = {
    "max_2_cards": 4,
    "max_cards_per_player": 13,
    "power_base": 2,
    "card_mult": CARD_MULT,
}

# main.py
import pandas as pd
from config import PLAYERS_CONFIG, RULES_CONFIG, EXCEL_FILE_PATH, CARD_PRICE
 
def calculate_single_loss(remain_cards, remain_2, rules):
    if remain_cards == 0:
        return 0.0
    power_mult = rules["power_base"] ** remain_2
    card_mult = rules["card_mult"][remain_cards]
    return remain_cards * power_mult * card_mult * CARD_PRICE
 
def safe_convert_to_int(value, desc, round_num):
    try:
        return int(value), ""
    except (ValueError, TypeError):
        return None, f"第{round_num}局 {desc} 不是有效数字"
 
def validate_round_data(row, round_num, players, rules):
    errors = []
    player_codes = list(players.keys())
    player_data = {}
 
    col_idx = 0
    for code in player_codes:
        player_name = players[code]
        cards_val = row.iloc[col_idx]
        cards, err = safe_convert_to_int(cards_val, f"{player_name}剩牌数", round_num)
        if err:
            errors.append(err)
            col_idx += 2
            continue
 
        remain_2_val = row.iloc[col_idx + 1]
        remain_2, err2 = safe_convert_to_int(remain_2_val, f"{player_name}被抓2数", round_num)
        if err2:
            errors.append(err2)
            col_idx += 2
            continue
 
        player_data[code] = {"name": player_name, "cards": cards, "remain_2": remain_2}
        col_idx += 2
 
    if errors:
        return False, " | ".join(errors), None
 
    for code, data in player_data.items():
        if data["remain_2"] > data["cards"]:
            errors.append(f"{data['name']} 被抓2数({data['remain_2']}) > 剩牌数({data['cards']})")
 
    total_remain_2 = sum(d["remain_2"] for d in player_data.values())
    if total_remain_2 < 0 or total_remain_2 > rules["max_2_cards"]:
        errors.append(f"全局被抓2总数={total_remain_2}，超出范围（0~{rules['max_2_cards']}）")
 
    for code, data in player_data.items():
        if data["cards"] < 0 or data["cards"] > rules["max_cards_per_player"]:
            errors.append(f"{data['name']} 剩牌数({data['cards']}) 超出范围（0~{rules['max_cards_per_player']}）")
 
    winner_count = sum(1 for d in player_data.values() if d["cards"] == 0)
    if winner_count == 0:
        errors.append("无赢家（无玩家剩牌数=0）")
    elif winner_count > 1:
        errors.append(f"赢家数量={winner_count}，每局只能有 1 个赢家")
 
    if errors:
        return False, f"第{round_num}局数据异常：" + " | ".join(errors), None
    return True, "", player_data
 
def main():
    try:
        df = pd.read_excel(EXCEL_FILE_PATH, header=0)
        print(f"✅ 成功读取 Excel（玩家：{PLAYERS_CONFIG}）")
        print("=" * 80)
    except FileNotFoundError:
        print(f"❌ 未找到文件：{EXCEL_FILE_PATH}")
        return
 
    total_scores = {name: 0.0 for name in PLAYERS_CONFIG.values()}
 
    for index, row in df.iterrows():
        round_num = index + 1
        is_valid, error_msg, player_data = validate_round_data(
            row, round_num, PLAYERS_CONFIG, RULES_CONFIG
        )
        if not is_valid:
            print(f"❌ {error_msg}")
            return
 
        round_losses = {}
        total_round_loss = 0.0
        winner_name = None
 
        for data in player_data.values():
            loss = calculate_single_loss(data["cards"], data["remain_2"], RULES_CONFIG)
            round_losses[data["name"]] = loss
            total_round_loss += loss
            if data["cards"] == 0:
                winner_name = data["name"]
 
        print(f"📌 第 {round_num} 局 | 赢家：{winner_name}")
        for name in PLAYERS_CONFIG.values():
            if name == winner_name:
                total_scores[name] += total_round_loss
                print(f"  {name}: 赢 {total_round_loss:.2f} 元")
            else:
                total_scores[name] -= round_losses[name]
                print(f"  {name}: 输 {round_losses[name]:.2f} 元")
        print("-" * 80)
 
    print("\n🏆 最终输赢结果")
    for name, score in total_scores.items():
        label = "赢" if score > 0 else ("输" if score < 0 else "平")
        print(f"{name}: 总共{label} {abs(score):.2f} 元")
 
if __name__ == "__main__":
    main()

pip install pandas openpyxl
python main.py

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
 
contract ChuDiDiScore {
    uint256 public constant CARD_PRICE = 1;
    uint256 public constant POWER_BASE = 2;
    uint256 public constant MAX_2_CARDS = 4;
    uint256 public constant MAX_CARDS = 13;
 
    address[4] public players;
    string[4] public playerNames;
    mapping(address => int256) public totalScores;
 
    struct Round {
        uint256 roundId;
        address winner;
        int256[4] scores;
        uint256[4] remainCards;
        uint256[4] remain2;
    }
 
    Round[] public rounds;
    uint256 public roundCount;
 
    function createRoom(address[4] calldata _players, string[4] calldata _names) public {
        for (uint256 i = 0; i < 4; i++) {
            players[i] = _players[i];
            playerNames[i] = _names[i];
        }
        roundCount = 0;
    }
 
    function _calculateLoss(uint256 remainCards, uint256 remain2) internal pure returns (uint256) {
        if (remainCards == 0) return 0;
 
        uint256 power_mult = remain2 == 0 ? 1 : (uint256(2) ** remain2);
        uint256 card_mult = 1;
 
        if (remainCards == 13) card_mult = 4;
        else if (remainCards >= 10 && remainCards <= 12) card_mult = 3;
        else if (remainCards >= 8 && remainCards <= 9) card_mult = 2;
 
        return remainCards * power_mult * card_mult * CARD_PRICE;
    }
 
    function submitRound(uint256[4] calldata _remainCards, uint256[4] calldata _remain2) public {
        require(players[0] != address(0));
 
        uint256 winnerCount = 0;
        address winner;
        uint256 totalRemain2 = 0;
 
        for (uint256 i = 0; i < 4; i++) {
            require(_remainCards[i] <= MAX_CARDS);
            require(_remain2[i] <= _remainCards[i]);
            totalRemain2 += _remain2[i];
            if (_remainCards[i] == 0) {
                winnerCount++;
                winner = players[i];
            }
        }
 
        require(winnerCount == 1);
        require(totalRemain2 <= MAX_2_CARDS);
 
        int256[4] memory roundScores;
        uint256 totalWin = 0;
 
        for (uint256 i = 0; i < 4; i++) {
            if (_remainCards[i] == 0) continue;
            uint256 loss = _calculateLoss(_remainCards[i], _remain2[i]);
            roundScores[i] = -int256(loss);
            totalWin += loss;
        }
 
        for (uint256 i = 0; i < 4; i++) {
            if (players[i] == winner) {
                roundScores[i] = int256(totalWin);
                break;
            }
        }
 
        for (uint256 i = 0; i < 4; i++) {
            totalScores[players[i]] += roundScores[i];
        }
 
        rounds.push(Round({
            roundId: roundCount + 1,
            winner: winner,
            scores: roundScores,
            remainCards: _remainCards,
            remain2: _remain2
        }));
        roundCount++;
    }
}

from flask import Flask, request, jsonify
from web3 import Web3
 
w3 = Web3(Web3.HTTPProvider('http://127.0.0.1:8545'))
 
ABI = [
    {
        "inputs": [
            {"internalType": "address[4]", "name": "_players", "type": "address[4]"},
            {"internalType": "string[4]", "name": "_names", "type": "string[4]"}
        ],
        "name": "createRoom",
        "outputs": [],
        "stateMutability": "nonpayable",
        "type": "function"
    },
    {
        "inputs": [
            {"internalType": "uint256[4]", "name": "_remainCards", "type": "uint256[4]"},
            {"internalType": "uint256[4]", "name": "_remain2", "type": "uint256[4]"}
        ],
        "name": "submitRound",
        "outputs": [],
        "stateMutability": "nonpayable",
        "type": "function"
    },
    {"inputs": [], "name": "roundCount", "outputs": [{"internalType": "uint256", "name": "", "type": "uint256"}], "stateMutability": "view", "type": "function"},
    {"inputs": [{"internalType": "uint256", "name": "", "type": "uint256"}], "name": "players", "outputs": [{"internalType": "address", "name": "", "type": "address"}], "stateMutability": "view", "type": "function"},
    {"inputs": [{"internalType": "uint256", "name": "", "type": "uint256"}], "name": "playerNames", "outputs": [{"internalType": "string", "name": "", "type": "string"}], "stateMutability": "view", "type": "function"},
    {"inputs": [{"internalType": "address", "name": "", "type": "address"}], "name": "totalScores", "outputs": [{"internalType": "int256", "name": "", "type": "int256"}], "stateMutability": "view", "type": "function"},
]
 
CONTRACT_ADDRESS = "0x5FbDB2315678afecb367f032d93F642f64180aa3"
contract = w3.eth.contract(address=CONTRACT_ADDRESS, abi=ABI)
account = w3.eth.accounts[0]
 
app = Flask(__name__)
 
@app.route('/createRoom', methods=['POST'])
def create_room():
    data = request.json
    names = data.get("names", ["张三", "李四", "王五", "赵六"])
    players = w3.eth.accounts[:4]
    tx_hash = contract.functions.createRoom(players, names).transact({"from": account})
    w3.eth.wait_for_transaction_receipt(tx_hash)
    return jsonify({"code": 0, "msg": "房间创建成功", "players": players, "names": names})
 
@app.route('/submitRound', methods=['POST'])
def submit_round():
    data = request.json
    tx_hash = contract.functions.submitRound(
        data["remainCards"], data["remain2"]
    ).transact({"from": account})
    w3.eth.wait_for_transaction_receipt(tx_hash)
    return jsonify({"code": 0, "msg": "本局成绩已上链"})
 
@app.route('/scores', methods=['GET'])
def get_scores():
    result = []
    for i in range(4):
        addr = contract.functions.players(i).call()
        result.append({
            "name": contract.functions.playerNames(i).call(),
            "score": int(contract.functions.totalScores(addr).call())
        })
    return jsonify({"code": 0, "scores": result})
 
@app.route('/roundCount', methods=['GET'])
def round_count():
    return jsonify({"code": 0, "roundCount": int(contract.functions.roundCount().call())})
 
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)