恶魔之轮 7.0 版本

废话不多说，上代码

# 版权说明
print("""
================================================================================
版权声明：本文为博主原创文章，遵循 [CC 4.0 BY-SA ](https://creativecommons.org/licenses/by-sa/4.0/) 版权协议，转载请附上原文出处链接和本声明。
================================================================================
""")

import time
import random


class ComputerPlayer:
    def __init__(self):
        self.name = "电脑"
        self.health = 5
        self.items = []
        self.shield = False
        self.coins = 0
        self.buffed = False
        self.handcuffed = False
        self.robot_active = False


def slow_print(text, delay=0.000001):
    """以较慢速度逐字打印文本，模拟字幕效果"""
    for char in text:
        print(char, end='', flush=True)
        time.sleep(delay)
    print()


def introduce_rules():
    """介绍游戏规则"""
    slow_print("欢迎来到恶魔之轮游戏！以下是游戏规则：")
    slow_print("1. 本游戏有两种模式：玩家对战和人机对战，双方初始血量均为5点。")
    slow_print("2. 游戏开始时，每位玩家会随机获得3种不同的道具，每轮结束后，每位玩家再随机获得2种道具。")
    slow_print("3. 道具及作用：")
    slow_print(" - 小烟：使用后可恢复1点血量。")
    slow_print(" - 放大镜：使用后能查看下一发子弹是实弹还是空弹。")
    slow_print(" - 扳手：使用后直接对对手造成1点伤害。")
    slow_print(" - 小刀：若下一发为实弹，使用时伤害额外加1，即造成2点伤害；若为空弹，仅造成1点伤害。")
    slow_print(" - 手雷：范围伤害，可使所有玩家血量 - 3。")
    slow_print(" - 盾牌：可免疫50%的伤害，价格：3枚金币。")
    slow_print(" - 剑：使伤害增加10%，价格：4枚金币。")
    slow_print(" - 伤害药水：下一次攻击伤害翻倍，价格：5枚金币。")
    slow_print(" - 手铐：使对手下一轮直接跳过，价格：3枚金币。")
    slow_print(" - 机器人：召唤一个助手，目标始终为召唤人的对手，不会攻击恶魔，1轮后消失，价格：6枚金币。")
    slow_print("4. 游戏中会随机生成实弹和空弹，两者数量之和为10。")
    slow_print("5. 实弹射击可扣减对手1滴血，空弹射击无伤害，射击一次对应子弹数量减1。")
    slow_print("6. 每轮玩家可以选择射击、使用道具或跳过本轮，使用完道具后仍可继续操作。")
    slow_print("7. 玩家现在可以选择射击自己。")
    slow_print("8. 当一方玩家的血量归零，则该玩家输掉游戏。")
    slow_print("9. 如果实弹和空弹数都为0，则恶魔开始行动，行动前，实弹数恢复成10，空弹数为0。")
    slow_print(" - 恶魔可以随机攻击玩家一或玩家二。")
    slow_print(" - 玩家一、二也可以选择攻击彼此或恶魔。")
    slow_print(" - 恶魔行动重复5次后轮到玩家一、玩家二，玩家二弄完后继续轮到恶魔，直至只剩下1个人存活。")
    slow_print(" - 死去的玩家不可以继续操作。")
    slow_print("10. 在执行完3或4轮后开始小游戏时间：")
    slow_print(" - 恶魔大战：一旦开始，两位玩家则收到3滴血的伤害，执行完1轮后退出。")
    slow_print(" - 菜鸟互啄：玩家每次可以执行两个操作，操作1：防御盾，可以免疫一次伤害；操作2：啄啄，可以直接对对手造成2滴伤害，执行完2轮后退出。")
    slow_print(" - 双枪设计：游戏时，玩家手上的枪增加一把，同时射出的子弹数量也为二，其余规则和普通一致，执行完1轮后跳出。")
    slow_print(" - 趣味躲靶：两位玩家依次选择往上、下、左、右躲避，此时会有一个恶魔，随机往三个方向射出子弹，如果玩家的躲避方向和恶魔子弹射出的方向中的任何一个相同则血量 - 2。")
    slow_print("11. 游戏中可以获得金币，金币可用于购买道具。每轮玩家有50%的概率获得1 - 3枚金币。")
    slow_print("后续情节规则：")
    slow_print("在恶魔之轮游戏中玩家胜利后，将解锁新的情节：")
    slow_print("神秘信使：玩家在游戏中偶然遇到一个神秘的信使，他带着一封来自未知发件人的信件。信件内容暗示了恶魔之轮背后隐藏着一个更大的阴谋，而玩家被选中来揭开这个秘密。信使会在特定的地点和时间出现，引导玩家完成一系列任务，以获取更多关于阴谋的线索。这些任务可能包括在危险的区域寻找古老的符文，或者与隐藏在暗处的神秘人物交流。")
    slow_print("记忆碎片：玩家在探索恶魔之轮的世界时，会发现一些神秘的记忆碎片。这些碎片属于一个曾经试图阻止恶魔之轮转动的英雄，但他的记忆被邪恶力量分割。玩家需要收集这些碎片，每收集一片，就会解锁一段关于这位英雄的回忆，包括他与恶魔的战斗、与同伴的合作以及最终失败的原因。通过这些回忆，玩家可以了解到更多关于恶魔之轮的历史和弱点，同时也能发现一些隐藏的线索，帮助他们在游戏中取得进展。")
    slow_print("隐藏教派：在游戏世界中，玩家发现了一个隐藏的教派，他们秘密崇拜着恶魔之轮的力量。这个教派的成员分散在各个角落，通过秘密仪式和符号来传递信息。玩家需要深入调查这个教派，了解他们的目的和计划。在调查过程中，玩家可能会遇到教派的守护者，他们会阻止玩家的行动。玩家需要通过解谜、战斗等方式来突破他们的防线，最终揭露教派的秘密，这可能会导致玩家与教派的首领展开一场惊心动魄的对决。")
    slow_print("时空裂缝：在游戏的某个关键节点，玩家触发了一个神秘的事件，导致时空裂缝出现。这些裂缝连接着不同的时间和空间，里面隐藏着各种危险和机遇。玩家可以选择进入裂缝，探索不同的世界，每个世界都有独特的敌人、宝藏和任务。在裂缝中，时间的流动可能会变得异常，玩家需要适应这种变化，同时利用裂缝中的特殊环境来解决谜题和战胜敌人。通过探索时空裂缝，玩家可以获得强大的道具和技能，这些将有助于他们在恶魔之轮的挑战中取得优势。")
    slow_print("同伴背叛：玩家在游戏中结识了一位强大的同伴，他们一起并肩作战，共同面对恶魔之轮带来的挑战。然而，在游戏的某个关键时刻，同伴突然背叛了玩家，原来他被恶魔的力量所诱惑，企图利用玩家来获取恶魔之轮的控制权。玩家需要在被背叛的困境中寻找出路，一方面要躲避同伴的追杀，另一方面要揭露他的阴谋并阻止他。在这个过程中，玩家可能会发现同伴背叛的背后还有更深层次的原因，这将使玩家陷入道德和情感的困境，同时也增加了游戏的剧情深度和紧张感。")
    slow_print("注意：有任意一个情节失败则整个游戏结束。")
    slow_print("在恶魔之轮结束后，活着的玩家可以选择是否救另一个玩家，如果选择救则后面的游戏呈两人游戏，否则为一人游戏。")


def get_random_items():
    """随机获取3种不同道具"""
    all_items = ["小烟", "放大镜", "扳手", "小刀"]
    return random.sample(all_items, 3)


def add_random_items(player):
    """每轮结束后为玩家随机添加2种道具"""
    all_items = ["小烟", "放大镜", "扳手", "小刀"]
    if isinstance(player, ComputerPlayer):
        player.items.extend(random.choices(all_items, k=2))
    else:
        player["items"].extend(random.choices(all_items, k=2))


def generate_bullets():
    """随机生成实弹和空弹数量，总和为10"""
    real_count = random.randint(1, 9)
    empty_count = 10 - real_count
    return real_count, empty_count


def shoot(shooter, target, real_count, empty_count, bullet_num=1):
    """执行射击操作"""
    if real_count + empty_count == 0:
        slow_print("没有子弹了，无法射击！")
        return real_count, empty_count
    total_damage = 0
    for _ in range(bullet_num):
        if random.random() < real_count / (real_count + empty_count):
            damage = 1
            if isinstance(shooter, ComputerPlayer) and shooter.buffed:
                damage = int(damage * 1.1)
            elif isinstance(shooter, dict) and shooter.get("buffed", False):
                damage = int(damage * 1.1)
            if isinstance(target, ComputerPlayer) and target.shield:
                damage = int(damage * 0.5)
            elif isinstance(target, dict) and target.get("shield", False):
                damage = int(damage * 0.5)
            if isinstance(target, ComputerPlayer):
                target.health = max(0, target.health - damage)
            else:
                target["health"] = max(0, target["health"] - damage)
            slow_print(f"{shooter['name'] if not isinstance(shooter, ComputerPlayer) else shooter.name} 射出实弹，{target['name'] if not isinstance(target, ComputerPlayer) else target.name} 受到 {damage} 点伤害！")
            total_damage += damage
            real_count -= 1
        else:
            slow_print(f"{shooter['name'] if not isinstance(shooter, ComputerPlayer) else shooter.name} 射出空弹，未造成伤害！")
            empty_count -= 1
    return real_count, empty_count


def use_item(player, opponents, real_count, empty_count, player1, player2):
    """使用道具的逻辑"""
    items = player.items if isinstance(player, ComputerPlayer) else player["items"]
    if not items:
        slow_print("你没有道具可以使用！")
        return real_count, empty_count
    slow_print("你拥有的道具：")
    for i, item in enumerate(items, start=1):
        slow_print(f"{i}. {item}")
    while True:
        try:
            choice = int(input("请输入要使用的道具编号（输入0取消）："))
            if choice == 0:
                break
            elif 1 <= choice <= len(items):
                item = items.pop(choice - 1)
                if item == "小烟":
                    if isinstance(player, ComputerPlayer):
                        player.health = min(player.health + 1, 5)
                    else:
                        player["health"] = min(player["health"] + 1, 5)
                    slow_print(f"{player['name'] if not isinstance(player, ComputerPlayer) else player.name} 使用小烟，恢复1点血量，当前血量：{player['health'] if not isinstance(player, ComputerPlayer) else player.health}。")
                elif item == "放大镜":
                    next_is_real = random.random() < real_count / (real_count + empty_count)
                    bullet_type = "实弹" if next_is_real else "空弹"
                    slow_print(f"下一发子弹是 {bullet_type}。")
                elif item == "扳手":
                    slow_print("请选择攻击对象：")
                    all_opponents = opponents + [player] if not isinstance(player, ComputerPlayer) else opponents + [player]
                    valid_opponents = [opponent for opponent in all_opponents if (isinstance(opponent, ComputerPlayer) and opponent.health > 0) or (not isinstance(opponent, ComputerPlayer) and opponent["health"] > 0)]
                    for i, opponent in enumerate(valid_opponents, start=1):
                        slow_print(f"{i}. {opponent['name'] if not isinstance(opponent, ComputerPlayer) else opponent.name}")
                    while True:
                        try:
                            target_choice = int(input("请输入攻击对象编号："))
                            if 1 <= target_choice <= len(valid_opponents):
                                target = valid_opponents[target_choice - 1]
                                if isinstance(target, ComputerPlayer):
                                    target.health = max(0, target.health - 1)
                                else:
                                    target["health"] = max(0, target["health"] - 1)
                                slow_print(f"{player['name'] if not isinstance(player, ComputerPlayer) else player.name} 使用扳手，{target['name'] if not isinstance(target, ComputerPlayer) else target.name} 受到1点伤害！")
                                break
                            else:
                                slow_print("输入无效，请重新输入！")
                        except ValueError:
                            slow_print("输入无效，请输入数字！")
                elif item == "小刀":
                    slow_print("请选择攻击对象：")
                    all_opponents = opponents + [player] if not isinstance(player, ComputerPlayer) else opponents + [player]
                    valid_opponents = [opponent for opponent in all_opponents if (isinstance(opponent, ComputerPlayer) and opponent.health > 0) or (not isinstance(opponent, ComputerPlayer) and opponent["health"] > 0)]
                    for i, opponent in enumerate(valid_opponents, start=1):
                        slow_print(f"{i}. {opponent['name'] if not isinstance(opponent, ComputerPlayer) else opponent.name}")
                    while True:
                        try:
                            target_choice = int(input("请输入攻击对象编号："))
                            if 1 <= target_choice <= len(valid_opponents):
                                target = valid_opponents[target_choice - 1]
                                next_is_real = random.random() < real_count / (real_count + empty_count)
                                damage = 2 if next_is_real else 1
                                if isinstance(target, ComputerPlayer):
                                    target.health = max(0, target.health - damage)
                                else:
                                    target["health"] = max(0, target["health"] - damage)
                                bullet_type = "实弹" if next_is_real else "空弹"
                                slow_print(f"{player['name'] if not isinstance(player, ComputerPlayer) else player.name} 使用小刀，下一发是 {bullet_type}，{target['name'] if not isinstance(target, ComputerPlayer) else target.name} 受到 {damage} 点伤害！")
                                if next_is_real:
                                    real_count -= 1
                                else:
                                    empty_count -= 1
                                break
                            else:
                                slow_print("输入无效，请重新输入！")
                        except ValueError:
                            slow_print("输入无效，请输入数字！")
                elif item == "手雷":
                    if isinstance(player1, ComputerPlayer):
                        player1.health = max(0, player1.health - 3)
                    else:
                        player1["health"] = max(0, player1["health"] - 3)
                    if isinstance(player2, ComputerPlayer):
                        player2.health = max(0, player2.health - 3)
                    else:
                        player2["health"] = max(0, player2["health"] - 3)
                    slow_print(f"{player['name'] if not isinstance(player, ComputerPlayer) else player.name} 使用手雷，所有玩家受到3点伤害！")
                elif item == "盾牌":
                    if isinstance(player, ComputerPlayer):
                        player.shield = True
                    else:
                        player["shield"] = True
                    slow_print(f"{player['name'] if not isinstance(player, ComputerPlayer) else player.name} 使用盾牌，可免疫50%的伤害。")
                elif item == "剑":
                    if isinstance(player, ComputerPlayer):
                        player.buffed = True
                    else:
                        player["buffed"] = True
                    slow_print(f"{player['name'] if not isinstance(player, ComputerPlayer) else player.name} 使用剑，伤害增加10%。")
                elif item == "伤害药水":
                    slow_print("请选择攻击对象：")
                    all_opponents = opponents + [player] if not isinstance(player, ComputerPlayer) else opponents + [player]
                    valid_opponents = [opponent for opponent in all_opponents if (isinstance(opponent, ComputerPlayer) and opponent.health > 0) or (not isinstance(opponent, ComputerPlayer) and opponent["health"] > 0)]
                    for i, opponent in enumerate(valid_opponents, start=1):
                        slow_print(f"{i}. {opponent['name'] if not isinstance(opponent, ComputerPlayer) else opponent.name}")
                    while True:
                        try:
                            target_choice = int(input("请输入攻击对象编号："))
                            if 1 <= target_choice <= len(valid_opponents):
                                target = valid_opponents[target_choice - 1]
                                next_is_real = random.random() < real_count / (real_count + empty_count)
                                if next_is_real:
                                    damage = 2
                                    if isinstance(target, ComputerPlayer) and target.shield:
                                        damage = int(damage * 0.5)
                                    elif isinstance(target, dict) and target.get("shield", False):
                                        damage = int(damage * 0.5)
                                    if isinstance(target, ComputerPlayer):
                                        target.health = max(0, target.health - damage)
                                    else:
                                        target["health"] = max(0, target["health"] - damage)
                                bullet_type = "实弹" if next_is_real else "空弹"
                                slow_print(f"{player['name'] if not isinstance(player, ComputerPlayer) else player.name} 使用伤害药水，下一发是 {bullet_type}，{target['name'] if not isinstance(target, ComputerPlayer) else target.name} 受到 {damage} 点伤害！")
                                if next_is_real:
                                    real_count -= 1
                                else:
                                    empty_count -= 1
                                break
                            else:
                                slow_print("输入无效，请重新输入！")
                        except ValueError:
                            slow_print("输入无效，请输入数字！")
                elif item == "手铐":
                    slow_print("请选择要使用手铐的对象：")
                    all_opponents = opponents + [player] if not isinstance(player, ComputerPlayer) else opponents + [player]
                    valid_opponents = [opponent for opponent in all_opponents if (isinstance(opponent, ComputerPlayer) and opponent.health > 0) or (not isinstance(opponent, ComputerPlayer) and opponent["health"] > 0)]
                    for i, opponent in enumerate(valid_opponents, start=1):
                        slow_print(f"{i}. {opponent['name'] if not isinstance(opponent, ComputerPlayer) else opponent.name}")
                    while True:
                        try:
                            target_choice = int(input("请输入对象编号："))
                            if 1 <= target_choice <= len(valid_opponents):
                                target = valid_opponents[target_choice - 1]
                                if isinstance(target, ComputerPlayer):
                                    target.handcuffed = True
                                else:
                                    target["handcuffed"] = True
                                slow_print(f"{player['name'] if not isinstance(player, ComputerPlayer) else player.name} 使用手铐，{target['name'] if not isinstance(target, ComputerPlayer) else target.name} 下一轮将直接跳过！")
                                break
                            else:
                                slow_print("输入无效，请重新输入！")
                        except ValueError:
                            slow_print("输入无效，请输入数字！")
                elif item == "机器人":
                    if isinstance(player, ComputerPlayer):
                        player.robot_active = True
                    else:
                        player["robot_active"] = True
                    opponent = [p for p in [player1, player2] if p != player][0]
                    slow_print(f"{player['name'] if not isinstance(player, ComputerPlayer) else player.name} 召唤了机器人，机器人将攻击 {opponent['name'] if not isinstance(opponent, ComputerPlayer) else opponent.name}！")
                    real_count, empty_count = shoot({"name": "机器人"}, opponent, real_count, empty_count)
                break
            else:
                slow_print("输入无效，请重新输入！")
        except ValueError:
            slow_print("输入无效，请输入数字！")
    return real_count, empty_count


def demon_action(demon, players, real_count, empty_count):
    """恶魔行动逻辑"""
    real_count = 10
    empty_count = 0
    valid_players = [player for player in players if (isinstance(player, ComputerPlayer) and player.health > 0) or (not isinstance(player, ComputerPlayer) and player["health"] > 0)]
    if not valid_players:
        return real_count, empty_count
    target = random.choice(valid_players)
    real_count, empty_count = shoot(demon, target, real_count, empty_count)
    return real_count, empty_count


def demon_war(player1, player2):
    """恶魔大战小游戏"""
    slow_print("恶魔大战小游戏开始！两位玩家将受到3点伤害。")
    if isinstance(player1, ComputerPlayer):
        player1.health = max(0, player1.health - 3)
    else:
        player1["health"] = max(0, player1["health"] - 3)
    if isinstance(player2, ComputerPlayer):
        player2.health = max(0, player2.health - 3)
    else:
        player2["health"] = max(0, player2["health"] - 3)
    slow_print(f"玩家1剩余血量: {player1['health'] if not isinstance(player1, ComputerPlayer) else player1.health}")
    slow_print(f"玩家2剩余血量: {player2['health'] if not isinstance(player2, ComputerPlayer) else player2.health}")


def rookie_pecking(player1, player2):
    """菜鸟互啄小游戏"""
    slow_print("菜鸟互啄小游戏开始！")
    for round_num in range(2):
        for current_player, opponent in [(player1, player2), (player2, player1)]:
            if isinstance(current_player, ComputerPlayer):
                if current_player.health <= 0 or current_player.handcuffed:
                    current_player.handcuffed = False
                    continue
            else:
                if current_player["health"] <= 0 or current_player.get("handcuffed", False):
                    current_player["handcuffed"] = False
                    continue
            slow_print(f"\n轮到 {current_player['name'] if not isinstance(current_player, ComputerPlayer) else current_player.name} 行动！")
            slow_print("请选择操作：")
            slow_print("1. 防御盾（可免疫一次伤害）")
            slow_print("2. 啄啄（对对手造成2点伤害）")
            if isinstance(current_player, ComputerPlayer):
                action = random.randint(1, 2)
                slow_print(f"{current_player.name}（电脑）选择操作: {action}")
            else:
                while True:
                    try:
                        action = int(input("请输入操作编号："))
                        break
                    except ValueError:
                        slow_print("输入无效，请输入数字！")
            if action == 1:
                if isinstance(current_player, ComputerPlayer):
                    current_player.shield = True
                else:
                    current_player["shield"] = True
                slow_print(f"{current_player['name'] if not isinstance(current_player, ComputerPlayer) else current_player.name} 使用防御盾，可免疫一次伤害。")
            elif action == 2:
                if isinstance(opponent, ComputerPlayer):
                    if opponent.shield:
                        slow_print(f"{opponent.name} 使用了防御盾，免疫此次伤害。")
                        opponent.shield = False
                    else:
                        opponent.health = max(0, opponent.health - 2)
                        slow_print(f"{current_player.name} 啄啄，{opponent.name} 受到2点伤害！")
                else:
                    if opponent.get("shield", False):
                        slow_print(f"{opponent['name']} 使用了防御盾，免疫此次伤害。")
                        opponent["shield"] = False
                    else:
                        opponent["health"] = max(0, opponent["health"] - 2)
                        slow_print(f"{current_player['name']} 啄啄，{opponent['name']} 受到2点伤害！")


def dual_***_shooting(player1, player2, real_count, empty_count):
    """双枪设计小游戏"""
    slow_print("双枪设计小游戏开始！")
    for current_player, opponent in [(player1, player2), (player2, player1)]:
        if isinstance(current_player, ComputerPlayer):
            if current_player.health <= 0 or current_player.handcuffed:
                current_player.handcuffed = False
                continue
        else:
            if current_player["health"] <= 0 or current_player.get("handcuffed", False):
                current_player["handcuffed"] = False
                continue
        slow_print(f"\n轮到 {current_player['name'] if not isinstance(current_player, ComputerPlayer) else current_player.name} 行动！")
        real_count, empty_count = shoot(current_player, opponent, real_count, empty_count, bullet_num=2)
    return real_count, empty_count


def fun_target_dodging(player1, player2):
    """趣味躲靶小游戏"""
    directions = ["上", "下", "左", "右"]
    slow_print("趣味躲靶小游戏开始！")
    for current_player in [player1, player2]:
        if isinstance(current_player, ComputerPlayer):
            if current_player.health <= 0 or current_player.handcuffed:
                current_player.handcuffed = False
                continue
        else:
            if current_player["health"] <= 0 or current_player.get("handcuffed", False):
                current_player["handcuffed"] = False
                continue
        slow_print(f"\n轮到 {current_player['name'] if not isinstance(current_player, ComputerPlayer) else current_player.name} 躲避！")
        if isinstance(current_player, ComputerPlayer):
            choice = random.choice(directions)
            slow_print(f"{current_player.name}（电脑）选择 {choice}")
        else:
            while True:
                choice = input("请选择躲避方向（上、下、左、右）：").strip()
                if choice in directions:
                    break
                else:
                    slow_print("输入无效，请重新输入！")
        demon_choices = random.sample(directions, 3)
        if choice in demon_choices:
            if isinstance(current_player, ComputerPlayer):
                current_player.health = max(0, current_player.health - 2)
            else:
                current_player["health"] = max(0, current_player["health"] - 2)
            slow_print(f"{current_player['name'] if not isinstance(current_player, ComputerPlayer) else current_player.name} 被击中，受到2点伤害！")


def buy_grenade(player):
    """购买手雷逻辑"""
    if isinstance(player, ComputerPlayer):
        if player.coins >= 2:
            player.items.append("手雷")
            player.coins -= 2
            slow_print(f"{player.name} 花费2枚金币购买了手雷，当前金币数: {player.coins}")
    else:
        if player["coins"] >= 2:
            confirm = input("你有足够的金币购买手雷，是否花费2枚金币购买？(y/n)：").strip().lower()
            if confirm == 'y':
                player["items"].append("手雷")
                player["coins"] -= 2
                slow_print(f"{player['name']} 花费2枚金币购买了手雷，当前金币数: {player['coins']}")


def shop(player):
    """商店逻辑"""
    items_for_sale = {
        "盾牌": 3,
        "剑": 4,
        "伤害药水": 5,
        "手铐": 3,
        "机器人": 6
    }
    slow_print("欢迎来到商店！以下是可购买的道具：")
    for item, price in items_for_sale.items():
        slow_print(f"{item}：{price} 枚金币")
    while True:
        choice = input("请输入要购买的道具名称（输入 '退出' 离开商店）：").strip()
        if choice == "退出":
            break
        if choice in items_for_sale:
            price = items_for_sale[choice]
            if isinstance(player, ComputerPlayer):
                if player.coins >= price:
                    player.items.append(choice)
                    player.coins -= price
                    slow_print(f"{player.name} 花费 {price} 枚金币购买了 {choice}，当前金币数: {player.coins}")
                else:
                    slow_print("金币不足，无法购买！")
            else:
                if player["coins"] >= price:
                    player["items"].append(choice)
                    player["coins"] -= price
                    slow_print(f"{player['name']} 花费 {price} 枚金币购买了 {choice}，当前金币数: {player['coins']}")
                else:
                    slow_print("金币不足，无法购买！")
        else:
            slow_print("输入无效，请重新输入！")


def main_game():
    mode = input("请选择游戏模式（1. 玩家对战 2. 人机对战）：")
    player1 = {
        "name": "玩家1",
        "health": 5,
        "items": get_random_items(),
        "shield": False,
        "coins": 0,
        "buffed": False,
        "handcuffed": False,
        "robot_active": False
    }
    if mode == "1":
        player2 = {
            "name": "玩家2",
            "health": 5,
            "items": get_random_items(),
            "shield": False,
            "coins": 0,
            "buffed": False,
            "handcuffed": False,
            "robot_active": False
        }
    else:
        player2 = ComputerPlayer()
    real_count, empty_count = generate_bullets()
    round_num = 0
    while player1["health"] > 0 and (isinstance(player2, dict) and player2["health"] > 0 or isinstance(player2, ComputerPlayer) and player2.health > 0):
        round_num += 1
        slow_print(f"\n第 {round_num} 轮开始！")
        slow_print(f"玩家1血量: {player1['health']}，金币: {player1['coins']}")
        if isinstance(player2, dict):
            slow_print(f"玩家2血量: {player2['health']}，金币: {player2['coins']}")
        else:
            slow_print(f"玩家2（电脑）血量: {player2.health}，金币: {player2.coins}")

        if random.random() < 0.5:
            if isinstance(player2, dict):
                player2["coins"] += random.randint(1, 3)
                slow_print(f"{player2['name']} 获得 {player2['coins']} 枚金币，当前金币数: {player2['coins']}")
            else:
                player2.coins += random.randint(1, 3)
                slow_print(f"{player2.name} 获得 {player2.coins} 枚金币，当前金币数: {player2.coins}")
        if random.random() < 0.5:
            player1["coins"] += random.randint(1, 3)
            slow_print(f"{player1['name']} 获得 {player1['coins']} 枚金币，当前金币数: {player1['coins']}")

        # 玩家1购买道具逻辑
        while True:
            buy_choice = input(f"{player1['name']} 是否要进入商店购买道具？(y/n)：").strip().lower()
            if buy_choice == 'y':
                shop(player1)
                break
            elif buy_choice == 'n':
                break
            else:
                slow_print("输入无效，请重新输入！")

        slow_print(f"{player1['name']} 的回合：")
        if player1.get("handcuffed", False):
            slow_print(f"{player1['name']} 被手铐限制，本轮跳过！")
            player1["handcuffed"] = False
        else:
            while True:
                action = input("请选择操作（1. 射击 2. 使用道具 3. 跳过本轮）：")
                if action == "1":
                    if isinstance(player2, dict):
                        target = player2
                    else:
                        target = player2
                    real_count, empty_count = shoot(player1, target, real_count, empty_count)
                    break
                elif action == "2":
                    if isinstance(player2, dict):
                        real_count, empty_count = use_item(player1, [player2], real_count, empty_count, player1, player2)
                    else:
                        real_count, empty_count = use_item(player1, [player2], real_count, empty_count, player1, player2)
                    break
                elif action == "3":
                    break
                else:
                    slow_print("输入无效，请重新输入！")
        if real_count + empty_count == 0:
            demon = {"name": "恶魔"}
            real_count, empty_count = demon_action(demon, [player1, player2], real_count, empty_count)

        # 玩家2购买道具逻辑
        if isinstance(player2, dict):
            while True:
                buy_choice = input(f"{player2['name']} 是否要进入商店购买道具？(y/n)：").strip().lower()
                if buy_choice == 'y':
                    shop(player2)
                    break
                elif buy_choice == 'n':
                    break
                else:
                    slow_print("输入无效，请重新输入！")
            slow_print(f"{player2['name']} 的回合：")
        else:
            if random.random() < 0.3 and player2.coins >= 3:  # 电脑有30%概率进入商店
                shop(player2)
            slow_print(f"{player2.name} 的回合：")
        if isinstance(player2, ComputerPlayer) and player2.handcuffed:
            slow_print(f"{player2.name} 被手铐限制，本轮跳过！")
            player2.handcuffed = False
        else:
            while True:
                if isinstance(player2, dict):
                    action = input("请选择操作（1. 射击 2. 使用道具 3. 跳过本轮）：")
                else:
                    action = random.choice(["1", "2", "3"])
                    slow_print(f"{player2.name}（电脑）选择操作: {action}")
                if action == "1":
                    if isinstance(player2, dict):
                        target = player1
                    else:
                        target = player1
                    real_count, empty_count = shoot(player2, target, real_count, empty_count)
                    break
                elif action == "2":
                    if isinstance(player2, dict):
                        real_count, empty_count = use_item(player2, [player1], real_count, empty_count, player1, player2)
                    else:
                        real_count, empty_count = use_item(player2, [player1], real_count, empty_count, player1, player2)
                    break
                elif action == "3":
                    break
                else:
                    slow_print("输入无效，请重新输入！")
        if real_count + empty_count == 0:
            demon = {"name": "恶魔"}
            real_count, empty_count = demon_action(demon, [player1, player2], real_count, empty_count)

        add_random_items(player1)
        if isinstance(player2, dict):
            add_random_items(player2)
        else:
            add_random_items(player2)

        # 重置一些状态
        if isinstance(player1, dict):
            player1["shield"] = False
            player1["buffed"] = False
            player1["robot_active"] = False
        else:
            player1.shield = False
            player1.buffed = False
            player1.robot_active = False

        if isinstance(player2, dict):
            player2["shield"] = False
            player2["buffed"] = False
            player2["robot_active"] = False
        else:
            player2.shield = False
            player2.buffed = False
            player2.robot_active = False

        if 3 <= round_num <= 4:
            mini_game_choice = random.choice(["恶魔大战", "菜鸟互啄", "双枪设计", "趣味躲靶"])
            if mini_game_choice == "恶魔大战":
                demon_war(player1, player2)
            elif mini_game_choice == "菜鸟互啄":
                rookie_pecking(player1, player2)
            elif mini_game_choice == "双枪设计":
                real_count, empty_count = dual_***_shooting(player1, player2, real_count, empty_count)
            else:
                fun_target_dodging(player1, player2)

    if player1["health"] <= 0:
        if isinstance(player2, dict):
            slow_print(f"{player2['name']} 获胜！")
            winner = player2
        else:
            slow_print(f"{player2.name} 获胜！")
            winner = player2
    else:
        slow_print(f"{player1['name']} 获胜！")
        winner = player1

    # 询问获胜者是否救另一个玩家
    if isinstance(winner, dict):
        save_choice = input(f"{winner['name']}，你是否要救另一个玩家？(y/n)：").strip().lower()
    else:
        # 这里电脑默认不救，可根据需求修改逻辑
        save_choice = 'n'
        slow_print(f"{winner.name}（电脑）选择不救另一个玩家。")

    if save_choice == 'y':
        slow_print("另一个玩家被救起，后续游戏将以两人模式继续。")
        # 这里可以添加后续两人模式的新情节代码，比如进入神秘信使等情节
        new_episode(winner, [player1, player2])
    else:
        slow_print("另一个玩家未被救起，后续游戏将以单人模式继续。")
        # 这里可以添加后续单人模式的新情节代码，比如进入神秘信使等情节
        new_episode(winner, [winner])


def new_episode(winner, players):
    """新情节开始函数"""
    slow_print("恭喜你在恶魔之轮游戏中获胜，现在进入新的情节！")
    while True:
        print("请选择要进入的后续情节：")
        print("1. 神秘信使")
        print("2. 记忆碎片")
        print("3. 隐藏教派")
        print("4. 时空裂缝")
        print("5. 同伴背叛")
        print("6. 退出游戏")
        try:
            choice = int(input("请输入情节编号："))
            if choice == 1:
                mystery_messenger(players)
            elif choice == 2:
                memory_fragments(players)
            elif choice == 3:
                hidden_cult(players)
            elif choice == 4:
                time_space_rift(players)
            elif choice == 5:
                companion_betrayal(players)
            elif choice == 6:
                slow_print("游戏结束，感谢游玩！")
                break
            else:
                slow_print("输入无效，请重新输入！")
        except ValueError:
            slow_print("输入无效，请输入数字！")


def mystery_messenger(players):
    """神秘信使情节"""
    slow_print("你遇到了神秘信使，他给了你一封信件，暗示着恶魔之轮背后有更大的阴谋。")
    slow_print("信使要求你去危险区域寻找古老符文以获取更多线索。")
    # 这里可以添加寻找符文的具体逻辑，比如通过随机事件决定是否找到符文等
    success = random.random() < 0.7  # 70%的概率成功找到符文
    if success:
        slow_print("你成功找到了古老符文，获得了重要线索！")
    else:
        slow_print("你未能找到古老符文，此情节失败，游戏结束。")
        return False
    return True


def memory_fragments(players):
    """记忆碎片情节"""
    slow_print("你开始在恶魔之轮世界中寻找神秘的记忆碎片。")
    fragments_found = 0
    while fragments_found < 3:  # 假设需要找到3片碎片
        slow_print(f"你正在寻找第 {fragments_found + 1} 片记忆碎片...")
        success = random.random() < 0.6  # 60%的概率找到碎片
        if success:
            fragments_found += 1
            slow_print(f"你找到了第 {fragments_found} 片记忆碎片！")
        else:
            slow_print("你未能找到这一片记忆碎片，此情节失败，游戏结束。")
            return False
    slow_print("你成功收集齐所有记忆碎片，解锁了关于英雄的完整回忆！")
    return True


def hidden_cult(players):
    """隐藏教派情节"""
    slow_print("你发现了一个隐藏的教派，他们秘密崇拜恶魔之轮的力量。")
    slow_print("你开始深入调查这个教派，遇到了教派的守护者。")
    # 这里可以添加解谜或战斗的逻辑，比如通过猜谜、战斗等方式突破防线
    success = random.random() < 0.5  # 50%的概率突破防线
    if success:
        slow_print("你成功突破了教派守护者的防线，继续深入调查。")
        slow_print("最终你揭露了教派的秘密，与教派首领展开对决。")
        final_success = random.random() < 0.6  # 60%的概率战胜首领
        if final_success:
            slow_print("你战胜了教派首领，成功揭露了教派的阴谋！")
        else:
            slow_print("你在与教派首领的对决中失败，此情节失败，游戏结束。")
            return False
    else:
        slow_print("你未能突破教派守护者的防线，此情节失败，游戏结束。")
        return False
    return True


def time_space_rift(players):
    """时空裂缝情节"""
    slow_print("你触发了神秘事件，时空裂缝出现。")
    slow_print("你决定进入裂缝探索不同的世界。")
    world_num = 1
    while world_num <= 3:  # 假设探索3个不同的世界
        slow_print(f"你进入了第 {world_num} 个世界。")
        success = random.random() < 0.5  # 50%的概率在世界中完成任务
        if success:
            slow_print(f"你成功完成了第 {world_num} 个世界的任务，获得了强大的道具和技能！")
        else:
            slow_print(f"你在第 {world_num} 个世界中失败，此情节失败，游戏结束。")
            return False
        world_num += 1
    slow_print("你成功探索完所有时空裂缝世界，变得更加强大！")
    return True


def companion_betrayal(players):
    """同伴背叛情节"""
    if len(players) < 2:
        slow_print("单人模式无法触发同伴背叛情节，跳过此情节。")
        return True
    slow_print("你结识了一位强大的同伴，一起并肩作战。")
    slow_print("然而，在关键时刻，同伴突然背叛了你。")
    slow_print("你需要躲避同伴的追杀，并揭露他的阴谋。")
    # 这里可以添加躲避和揭露阴谋的逻辑，比如通过选择不同行动来决定是否成功
    success = random.random() < 0.4  # 40%的概率成功揭露阴谋
    if success:
        slow_print("你成功揭露了同伴的阴谋，阻止了他的行动！")
    else:
        slow_print("你未能揭露同伴的阴谋，此情节失败，游戏结束。")
        return False
    return True


if __name__ == "__main__":
    while True:
        print("1. 开始游戏")
        print("2. 查看游戏规则")
        print("3. 直接进入后续情节")
        print("4. 退出游戏")
        try:
            choice = int(input("请选择操作："))
            if choice == 1:
                main_game()
            elif choice == 2:
                introduce_rules()
            elif choice == 3:
                # 模拟一个获胜玩家进入后续情节
                mock_winner = {
                    "name": "模拟获胜者",
                    "health": 5,
                    "items": [],
                    "coins": 0
                }
                new_episode(mock_winner, [mock_winner])
            elif choice == 4:
                slow_print("游戏结束，感谢游玩！")
                break
            else:
                slow_print("输入无效，请重新输入！")
        except ValueError:
            slow_print("输入无效，请输入数字！")