综合python案例，两回合制首回合如何部署？

wen python案例 2026-08-25 160

本文目录导读：

🎮 综合案例：战术卡牌对战
🎯 首回合部署的核心逻辑要点
🎮 运行示例
📊 部署策略建议

我来为你设计一个完整的双回合制游戏/对战的Python综合案例，并详细解释首回合的部署逻辑。

🎮 综合案例：战术卡牌对战

完整的双回合制游戏框架

"""
双回合制战术卡牌对战系统
设计理念：每个玩家在首回合进行战略部署，之后进入行动回合
"""
import random
import time
from dataclasses import dataclass
from enum import Enum
from typing import List, Dict, Optional
# ========== 基础定义 ==========
class Phase(Enum):
    """游戏阶段"""
    DEPLOYMENT = "部署阶段"
    ACTION = "行动阶段"
    END = "结束阶段"
class CardType(Enum):
    """卡牌类型"""
    ATTACK = "攻击"
    DEFENSE = "防御"
    MAGIC = "魔法"
    BUFF = "增益"
    DEBUFF = "减益"
class Status(Enum):
    """状态效果"""
    NONE = "无"
    POISONED = "中毒"
    BURNED = "燃烧"
    FROZEN = "冻结"
    SHIELD = "护盾"
    BUFFED = "强化"
    DEBUFFED = "弱化"
@dataclass
class Card:
    """卡牌模型"""
    name: str
    type: CardType
    cost: int
    power: int
    description: str
    special_effect: Optional[str] = None
    def apply_effect(self, target: 'Player'):
        """应用卡牌效果"""
        if self.type == CardType.ATTACK:
            target.health -= self.power
            print(f"  ⚔️ {target.name} 受到 {self.power} 点伤害！")
        elif self.type == CardType.DEFENSE:
            target.health += self.power
            print(f"  🛡️ {target.name} 恢复 {self.power} 点生命值！")
        elif self.type == CardType.MAGIC:
            target.health -= self.power * 1.5
            print(f"  🔮 {target.name} 受到魔法伤害 {self.power * 1.5} 点！")
        elif self.type == CardType.BUFF:
            target.attack_bonus += self.power
            print(f"  ↑ {target.name} 攻击力提升 {self.power} 点！")
        elif self.type == CardType.DEBUFF:
            target.defense_reduction = self.power
            print(f"  ↓ {target.name} 防御力降低 {self.power} 点！")
class Player:
    """玩家类"""
    def __init__(self, name: str):
        self.name = name
        self.health = 100
        self.max_health = 100
        self.energy = 10
        self.attack_bonus = 0
        self.defense_reduction = 0
        self.status_effects: Dict[Status, int] = {}  # 状态及其持续回合数
        self.hand: List[Card] = []
        self.deployed_cards: List[Card] = []
        self.reserve_cards: List[Card] = []
        self.has_started = False
    def draw_card(self, card_pool: List[Card]) -> Optional[Card]:
        """抽取卡牌"""
        if card_pool and len(self.hand) < 5:  # 手牌上限
            card = card_pool.pop(0)
            self.hand.append(card)
            return card
        return None
    def deploy_card(self, card: Card) -> bool:
        """部署卡牌（首回合核心操作）"""
        if self.energy < card.cost:
            print(f"  ⚠️ {self.name} 能量不足！需要 {card.cost} 能量")
            return False
        if card not in self.hand:
            print("  ⚠️ 卡牌不在手牌中")
            return False
        # 消耗能量并部署
        self.energy -= card.cost
        self.hand.remove(card)
        self.deployed_cards.append(card)
        return True
    def move_to_reserve(self, card: Card):
        """将卡牌移入备用区"""
        if card in self.deployed_cards:
            self.deployed_cards.remove(card)
            self.reserve_cards.append(card)
            print(f"  📦 {self.name} 将 {card.name} 移入备用区")
    def apply_turn_bonuses(self):
        """应用每回合开始的加成"""
        self.energy += 5  # 每回合恢复能量
        if Status.BUFFED in self.status_effects:
            self.attack_bonus += 2
            self.status_effects[Status.BUFFED] -= 1
            if self.status_effects[Status.BUFFED] <= 0:
                del self.status_effects[Status.BUFFED]
    def take_status_damage(self):
        """处理持续伤害效果"""
        if Status.POISONED in self.status_effects:
            damage = 5 * self.status_effects[Status.POISONED]
            self.health -= damage
            print(f"  ☠️ {self.name} 受到中毒伤害 {damage} 点")
        if Status.BURNED in self.status_effects:
            damage = 3
            self.health -= damage
            print(f"  🔥 {self.name} 受到燃烧伤害 {damage} 点")
        if Status.FROZEN in self.status_effects:
            print(f"  ❄️ {self.name} 被冻结，无法行动")
            self.status_effects[Status.FROZEN] -= 1
            if self.status_effects[Status.FROZEN] <= 0:
                del self.status_effects[Status.FROZEN]
            return False  # 无法行动
        return True  # 可以行动
    def display_state(self):
        """显示玩家状态"""
        print(f"\n{'='*40}")
        print(f"🎮 {self.name} 状态:")
        print(f"  生命: {self.health}/{self.max_health} ❤️")
        print(f"  能量: {self.energy} ⚡")
        print(f"  攻击加成: {self.attack_bonus} ⚔️")
        print(f"  防御削弱: {self.defense_reduction} 🛡️")
        if self.status_effects:
            print("  状态效果:")
            for status, rounds in self.status_effects.items():
                print(f"    {status.value} (剩余 {rounds} 回合)")
        if self.deployed_cards:
            print(f"  已部署卡牌 ({len(self.deployed_cards)}):")
            for card in self.deployed_cards:
                print(f"    ⭐ {card.name} - {card.type.value} ({card.power}点)")
        if self.reserve_cards:
            print(f"  备用卡牌 ({len(self.reserve_cards)}):")
            for card in self.reserve_cards:
                print(f"    📦 {card.name}")
        if self.hand:
            print(f"  手牌 ({len(self.hand)}):")
            for i, card in enumerate(self.hand):
                print(f"    [{i+1}] {card.name} - {card.type.value} - 消耗{card.cost}能量")
        print(f"{'='*40}")
class GameManager:
    """游戏管理器"""
    def __init__(self, player1: Player, player2: Player):
        self.player1 = player1
        self.player2 = player2
        self.card_pool: List[Card] = []
        self.current_round = 0
        self.max_rounds = 3
        self.game_phase = Phase.DEPLOYMENT
    def setup_card_pool(self):
        """初始化卡牌库"""
        card_definitions = [
            # 基础攻击
            Card("猛击", CardType.ATTACK, 3, 10, "造成10点伤害"),
            Card("重击", CardType.ATTACK, 5, 18, "造成18点伤害", "破甲"),
            # 防御卡
            Card("盾墙", CardType.DEFENSE, 2, 15, "恢复15点生命值"),
            Card("铁壁", CardType.DEFENSE, 4, 30, "恢复30点生命值"),
            # 魔法卡
            Card("火球术", CardType.MAGIC, 6, 20, "造成30点魔法伤害"),
            Card("冰霜新星", CardType.MAGIC, 7, 15, "造成22点伤害并冻结", "冻结"),
            # 增益卡
            Card("狂暴药剂", CardType.BUFF, 3, 5, "攻击力+5"),
            Card("战斗号角", CardType.BUFF, 5, 10, "攻击力+10"),
            # 减益卡
            Card("虚弱诅咒", CardType.DEBUFF, 4, 3, "目标防御降低"),
        ]
        # 创建多份卡牌
        for card_def in card_definitions:
            for _ in range(3):  # 每种卡牌3张
                self.card_pool.append(card_def)
        random.shuffle(self.card_pool)
        print(f"🃏 卡牌库初始化完毕，共 {len(self.card_pool)} 张卡牌")
    def initial_draw(self, player: Player, count: int = 5):
        """初始抽牌"""
        print(f"\n📖 {player.name} 初始抽牌:")
        for _ in range(count):
            card = player.draw_card(self.card_pool)
            if card:
                print(f"  抽到: {card.name} - {card.description}")
    def deployment_phase(self):
        """首回合部署阶段（核心逻辑）"""
        print("\n" + "="*50)
        print("🏰 首回合部署阶段")
        print("="*50)
        for player in [self.player1, self.player2]:
            print(f"\n🎯 {player.name} 部署回合:")
            player.display_state()
            # 部署操作
            deploying = True
            while deploying:
                print("\n可选操作:")
                print("1. 部署卡牌 (输入卡牌编号)")
                print("2. 跳过部署，进入行动阶段")
                print("3. 查看状态")
                print("0. 结束部署")
                action = input("请选择: ").strip()
                if action == "0":
                    deploying = False
                elif action == "1" or action == "":
                    # 选择卡牌部署
                    try:
                        card_idx = int(input("选择要部署的卡牌编号 (1-5): ")) - 1
                        if 0 <= card_idx < len(player.hand):
                            card = player.hand[card_idx]
                            if player.deploy_card(card):
                                print(f"  ✅ 成功部署 {card.name}")
                                # 特殊效果处理
                                if card.special_effect == "冻结":
                                    player.status_effects[Status.FROZEN] = 1
                                player.display_state()
                            else:
                                print("  ❌ 部署失败")
                        else:
                            print("  ⚠️ 无效的卡牌编号")
                    except ValueError:
                        print("  ⚠️ 请输入有效数字")
                elif action == "2":
                    print(f"  → {player.name} 结束部署")
                    deploying = False
                elif action == "3":
                    player.display_state()
        # 部署完成后进入行动阶段
        self.game_phase = Phase.ACTION
        print("\n✨ 部署阶段结束，进入行动阶段！")
        time.sleep(1)
    def action_phase(self):
        """行动阶段"""
        print("\n" + "="*50)
        print("⚔️ 行动阶段")
        print("="*50)
        for player in [self.player1, self.player2]:
            print(f"\n🎮 {player.name} 的回合:")
            # 应用回合开始加成
            player.apply_turn_bonuses()
            # 处理状态伤害
            can_act = player.take_status_damage()
            if can_act:
                player.display_state()
                # 选择行动
                action = input("\n1. 使用部署的卡牌\n2. 使用手牌卡牌\n3. 跳过\n选择: ")
                if action == "1" and player.deployed_cards:
                    print("可用部署卡牌:")
                    for i, card in enumerate(player.deployed_cards):
                        print(f"  [{i+1}] {card.name}")
                    use_idx = int(input("选择要使用的卡牌: ")) - 1
                    if 0 <= use_idx < len(player.deployed_cards):
                        target = self.get_target(player)
                        card = player.deployed_cards[use_idx]
                        card.apply_effect(target)
                        player.deployed_cards.remove(card)  # 使用后移除
                elif action == "2" and player.hand:
                    print("手牌:")
                    for i, card in enumerate(player.hand):
                        print(f"  [{i+1}] {card.name}")
                    use_idx = int(input("选择要使用的卡牌: ")) - 1
                    if 0 <= use_idx < len(player.hand):
                        target = self.get_target(player)
                        card = player.hand[use_idx]
                        if player.deploy_card(card):
                            card.apply_effect(target)
                            player.hand.remove(card)  # 直接使用
            # 显示更新后的状态
            player.display_state()
    def get_target(self, attacker: Player) -> Player:
        """获取攻击目标"""
        return self.player2 if attacker == self.player1 else self.player1
    def check_winner(self) -> Optional[Player]:
        """检查胜负"""
        if self.player1.health <= 0:
            return self.player2
        elif self.player2.health <= 0:
            return self.player1
        return None
    def run_game(self):
        """运行游戏主循环"""
        print("🎮 战术卡牌对战系统启动！")
        print(f"对局: {self.player1.name} VS {self.player2.name}")
        # 初始化
        self.setup_card_pool()
        self.initial_draw(self.player1)
        self.initial_draw(self.player2)
        # 首回合部署
        self.deployment_phase()
        # 后续回合
        while self.current_round < self.max_rounds:
            self.current_round += 1
            print(f"\n{'='*50}")
            print(f"第 {self.current_round} 回合")
            print(f"{'='*50}")
            self.action_phase()
            winner = self.check_winner()
            if winner:
                print(f"\n🏆 获胜者: {winner.name}!")
                break
            if self.current_round < self.max_rounds:
                print("\n🔄 回合结束，进入下一回合...")
                time.sleep(1)
        if not winner:
            print("\n🤝 平局！双方存活")
    def add_special_rule(self):
        """添加特殊规则（首回合特有）"""
        print("\n📜 首回合特殊规则:")
        print("1. 双方各有5次部署机会")
        print("2. 部署阶段结束后，能源自动恢复")
        print("3. 部署的卡牌在行动阶段自动激活")
# ========== 主程序 ==========
def main():
    """主入口"""
    print("🎮 欢迎来到战术卡牌对战系统！")
    # 创建玩家
    p1_name = input("玩家1名称: ") or "勇士甲"
    p2_name = input("玩家2名称: ") or "勇士乙"
    player1 = Player(p1_name)
    player2 = Player(p2_name)
    # 创建游戏
    game = GameManager(player1, player2)
    # 开始游戏
    game.run_game()
if __name__ == "__main__":
    main()

🎯 首回合部署的核心逻辑要点

部署阶段特有的流程

def deployment_phase(self):
    """首回合部署阶段（核心逻辑）"""
    # 每个玩家轮流部署
    for player in [self.player1, self.player2]:
        # 显示当前状态
        player.display_state()
        # 部署操作（循环直到玩家决定结束）
        while deploying:
            # 提供部署选项
            # 1. 从手牌中选择卡牌部署
            # 2. 跳过部署
            # 3. 查看状态

部署策略优化

def deploy_strategy(player):
    """部署策略建议"""
    strategies = {
        "防御优先": "先部署防御卡牌，减少初始伤害",
        "攻击优先": "部署强力攻击卡牌，争取先手优势",
        "均衡发展": "合理搭配攻击和防御卡牌",
        "隐藏实力": "保留部分卡牌在备用区，迷惑对手"
    }
    # 建议基于卡牌类型和当前状态
    if player.health < 60:
        return "防御优先"
    elif len(player.deployed_cards) < 2:
        return "攻击优先"
    else:
        return "均衡发展"

首回合资源管理

def manage_resources(player):
    """管理首回合资源"""
    print(f"⚡ 当前能量: {player.energy}")
    print(f"🃏 手牌数量: {len(player.hand)}")
    # 计算可部署卡牌的能量消耗
    total_cost = sum(card.cost for card in player.hand)
    print(f"📊 手牌总消耗: {total_cost}")
    if total_cost > player.energy:
        print("⚠️ 注意！能量不足以部署所有手牌")
        print("💡 建议：选择费用较低的卡牌优先部署")

🎮 运行示例

🎮 欢迎来到战术卡牌对战系统！
玩家1名称: 赵云
玩家2名称: 吕布
🃏 卡牌库初始化完毕，共 54 张卡牌
🏰 首回合部署阶段
🎯 赵云 部署回合:
🎮 赵云 状态:
  生命: 100/100 ❤️
  能量: 10 ⚡
  手牌 (5):
  [1] 猛击 - 攻击 - 消耗3能量
  [2] 盾墙 - 防御 - 消耗2能量
  [3] 火球术 - 魔法 - 消耗6能量
  [4] 狂暴药剂 - 增益 - 消耗3能量
  [5] 虚弱诅咒 - 减益 - 消耗4能量
请选择: 1
选择要部署的卡牌编号 (1-5): 1
  ✅ 成功部署 猛击
请选择: 1
选择要部署的卡牌编号 (1-5): 4
  ✅ 成功部署 狂暴药剂

📊 部署策略建议

首回合张弛有度

不要一次性用完所有能量
保留1-2张卡牌作为后续回合的战术选择
优先部署核心战术卡牌

情报收集

观察对手的部署模式
根据对手风格调整自己的部署
留意对手的卡牌类型分布

风险管理

def risk_assessment(player):
    """风险评估"""
    threats = 0
    for card in player.deployed_cards:
        if card.type in [CardType.ATTACK, CardType.MAGIC]:
            threats += card.power
    defenses = 0
    for card in player.deployed_cards:
        if card.type == CardType.DEFENSE:
            defenses += card.power
    print(f"📊 攻击威胁: {threats}")
    print(f"🛡️ 防御数值: {defenses}")
    # 建议
    if threats > defenses * 1.5:
        print("⚠️ 过于攻击性！建议增加防御")
    elif defenses > threats * 1.5:
        print("⚠️ 过于保守！建议增加攻击")
    else:
        print("✅ 攻守均衡，部署合理")

这个双回合制游戏实现了：