本文目录导读：
我来为你设计一个完整的双回合制游戏/对战的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("✅ 攻守均衡，部署合理")
这个双回合制游戏实现了：
- 完整的首回合部署系统
- 卡牌管理机制
- 状态效果系统
- 回合制战斗流程
- 灵活的部署策略
你可以根据实际需求：
- 调整卡牌效果和数值
- 添加更多特殊规则
- 增加AI对手
- 实现网络对战
- 扩展更多卡牌类型
通过这个案例,你可以深入理解双回合制游戏的核心逻辑和部署机制！
