2.0 版本，新增恶魔彩蛋以及小游戏

import time
import random



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


def introduce_rules():
    """介绍游戏规则"""
    slow_print("欢迎来到恶魔之轮游戏！以下是游戏规则：")
    slow_print("1. 本游戏有两名玩家进行 PK，双方初始血量均为 5 点。")
    slow_print("2. 游戏开始时，每位玩家会随机获得 3 种不同的道具，每轮结束后，每位玩家再随机获得 2 种道具。")
    slow_print("3. 道具及作用：")
    slow_print("   - 小烟：使用后可恢复 1 点血量。")
    slow_print("   - 放大镜：使用后能查看下一发子弹是实弹还是空弹。")
    slow_print("   - 扳手：使用后直接对对手造成 1 点伤害。")
    slow_print("   - 小刀：若下一发为实弹，使用时伤害额外加 1，即造成 2 点伤害；若为空弹，仅造成 1 点伤害。")
    slow_print("4. 游戏中会随机生成实弹和空弹，两者数量之和为 10。")
    slow_print("5. 实弹射击可扣减对手 1 滴血，空弹射击无伤害，射击一次对应子弹数量减 1。")
    slow_print("6. 每轮玩家可以选择射击、使用道具或跳过本轮，使用完道具后仍可继续操作。")
    slow_print("7. 当一方玩家的血量归零，则该玩家输掉游戏。")
    slow_print("8. 如果实弹和空弹数都为 0，则恶魔开始行动，行动前，实弹数恢复成 10，空弹数为 0。")
    slow_print("   - 恶魔可以随机攻击玩家一或玩家二。")
    slow_print("   - 玩家一、二也可以选择攻击彼此或恶魔。")
    slow_print("   - 恶魔行动重复 5 次后轮到玩家一、玩家二，玩家二弄完后继续轮到恶魔，直至只剩下 1 个人存活。")
    slow_print("   - 死去的玩家不可以继续操作。")
    slow_print("9. 在执行完 3 或 4 轮后开始小游戏时间：")
    slow_print("   - 恶魔大战：一旦开始，两位玩家则收到 3 滴血的伤害，执行完 1 轮后退出。")
    slow_print("   - 菜鸟互啄：玩家每次可以执行两个操作，操作 1：防御盾，可以免疫一次伤害；操作 2：啄啄，可以直接对对手造成 2 滴伤害，执行完 2 轮后退出。")
    slow_print("   - 双枪设计：游戏时，玩家手上的枪增加一把，同时射出的子弹数量也为二，其余规则和普通一致，执行完 1 轮后跳出。")
    slow_print("   - 趣味躲靶：两位玩家依次选择往上、下、左、右躲避，此时会有一个恶魔，随机往三个方向射出子弹，如果玩家的躲避方向和恶魔子弹射出的方向中的任何一个相同则血量 - 2。")


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


def add_random_items(player):
    """每轮结束后为玩家随机添加 2 种道具"""
    all_items = ["小烟", "放大镜", "扳手", "小刀"]
    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
    for _ in range(bullet_num):
        if random.random() < real_count / (real_count + empty_count):
            target["health"] -= 1
            slow_print(f"{shooter['name']} 射出实弹，{target['name']} 受到 1 点伤害！")
            real_count -= 1
        else:
            slow_print(f"{shooter['name']} 射出空弹，未造成伤害！")
            empty_count -= 1
    return real_count, empty_count


def use_item(player, opponents, real_count, empty_count):
    """使用道具的逻辑"""
    if not player["items"]:
        slow_print("你没有道具可以使用！")
        return real_count, empty_count
    slow_print("你拥有的道具：")
    for i, item in enumerate(player["items"], start=1):
        slow_print(f"{i}. {item}")
    while True:
        try:
            choice = int(input("请输入要使用的道具编号（输入 0 取消）："))
            if choice == 0:
                break
            elif 1 <= choice <= len(player["items"]):
                item = player["items"].pop(choice - 1)
                if item == "小烟":
                    player["health"] = min(player["health"] + 1, 5)
                    slow_print(f"{player['name']} 使用小烟，恢复 1 点血量，当前血量：{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("请选择攻击对象：")
                    for i, opponent in enumerate(opponents, start=1):
                        if opponent["health"] > 0:
                            slow_print(f"{i}. {opponent['name']}")
                    while True:
                        try:
                            target_choice = int(input("请输入攻击对象编号："))
                            valid_opponents = [opponent for opponent in opponents if opponent["health"] > 0]
                            if 1 <= target_choice <= len(valid_opponents):
                                target = valid_opponents[target_choice - 1]
                                target["health"] -= 1
                                slow_print(f"{player['name']} 使用扳手，{target['name']} 受到 1 点伤害！")
                                break
                            else:
                                slow_print("输入无效，请重新输入！")
                        except ValueError:
                            slow_print("输入无效，请输入数字！")
                elif item == "小刀":
                    slow_print("请选择攻击对象：")
                    for i, opponent in enumerate(opponents, start=1):
                        if opponent["health"] > 0:
                            slow_print(f"{i}. {opponent['name']}")
                    while True:
                        try:
                            target_choice = int(input("请输入攻击对象编号："))
                            valid_opponents = [opponent for opponent in opponents if opponent["health"] > 0]
                            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
                                target["health"] -= damage
                                bullet_type = "实弹" if next_is_real else "空弹"
                                slow_print(f"{player['name']} 使用小刀，下一发是 {bullet_type}，{target['name']} 受到 {damage} 点伤害！")
                                if next_is_real:
                                    real_count -= 1
                                else:
                                    empty_count -= 1
                                break
                            else:
                                slow_print("输入无效，请重新输入！")
                        except ValueError:
                            slow_print("输入无效，请输入数字！")
                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 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 点伤害。")
    player1["health"] = max(0, player1["health"] - 3)
    player2["health"] = max(0, player2["health"] - 3)
    slow_print(f"玩家 1 剩余血量: {player1['health']}")
    slow_print(f"玩家 2 剩余血量: {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 current_player["health"] <= 0:
                continue
            slow_print(f"\n轮到 {current_player['name']} 行动！")
            slow_print("请选择操作：")
            slow_print("1. 防御盾（可免疫一次伤害）")
            slow_print("2. 啄啄（对对手造成 2 点伤害）")
            while True:
                try:
                    action = int(input("请输入操作编号："))
                    if action == 1:
                        slow_print(f"{current_player['name']} 使用防御盾，可免疫一次伤害。")
                        current_player["shield"] = True
                    elif action == 2:
                        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 点伤害！")
                    else:
                        slow_print("输入无效，请重新输入！")
                        continue
                    break
                except ValueError:
                    slow_print("输入无效，请输入数字！")


def dual_***_shooting(player1, player2, real_count, empty_count):
    """双枪设计小游戏"""
    slow_print("双枪设计小游戏开始！玩家每次射击射出两颗子弹。")
    current_player = player1
    opponent = player2
    while True:
        if current_player["health"] <= 0 and opponent["health"] <= 0:
            break
        if current_player["health"] <= 0:
            current_player, opponent = opponent, current_player
            continue
        slow_print(f"\n轮到 {current_player['name']} 行动！")
        slow_print(f"{current_player['name']} 血量: {current_player['health']}")
        slow_print(f"{opponent['name']} 血量: {opponent['health']}")
        slow_print(f"实弹数量: {real_count}，空弹数量: {empty_count}")
        slow_print(f"{current_player['name']} 拥有的道具：{current_player['items']}")
        slow_print("请选择操作：")
        slow_print("1. 射击")
        slow_print("2. 使用道具")
        slow_print("3. 跳过本轮")
        while True:
            try:
                action = int(input("请输入操作编号："))
                if action == 1:
                    real_count, empty_count = shoot(current_player, opponent, real_count, empty_count, bullet_num=2)
                    break
                elif action == 2:
                    real_count, empty_count = use_item(current_player, [opponent], real_count, empty_count)
                    slow_print("你已使用道具，可继续选择操作：")
                    slow_print("1. 射击")
                    slow_print("3. 跳过本轮")
                    while True:
                        try:
                            sub_action = int(input("请输入操作编号："))
                            if sub_action == 1:
                                real_count, empty_count = shoot(current_player, opponent, real_count, empty_count, bullet_num=2)
                            elif sub_action == 3:
                                slow_print(f"{current_player['name']} 选择跳过本轮。")
                            else:
                                slow_print("输入无效，请重新输入！")
                                continue
                            break
                        except ValueError:
                            slow_print("输入无效，请输入数字！")
                    break
                elif action == 3:
                    slow_print(f"{current_player['name']} 选择跳过本轮。")
                    break
                else:
                    slow_print("输入无效，请重新输入！")
            except ValueError:
                slow_print("输入无效，请输入数字！")

        current_player, opponent = opponent, current_player


def fun_target_dodging(player1, player2):
    """趣味躲靶小游戏"""
    slow_print("趣味躲靶小游戏开始！")
    directions = ["上", "下", "左", "右"]
    for current_player in [player1, player2]:
        if current_player["health"] <= 0:
            continue
        slow_print(f"\n轮到 {current_player['name']} 选择躲避方向！请输入 上、下、左、右：")
        while True:
            dodge_direction = input().strip()
            if dodge_direction in directions:
                break
            else:
                slow_print("输入无效，请重新输入！")
        demon_shots = random.sample(directions, 3)
        slow_print(f"恶魔向 {', '.join(demon_shots)} 方向射出子弹。")
        if dodge_direction in demon_shots:
            current_player["health"] = max(0, current_player["health"] - 2)
            slow_print(f"{current_player['name']} 躲避失败，受到 2 点伤害！")
        else:
            slow_print(f"{current_player['name']} 躲避成功！")


def main():
    slow_print("欢迎来到恶魔之轮游戏！")
    slow_print("请选择：")
    slow_print("1：我已知晓规则，直接开始！！")
    slow_print("2：我还未知晓规则，请讲解")
    while True:
        try:
            choice = int(input("请输入选项编号："))
            if choice == 1:
                break
            elif choice == 2:
                introduce_rules()
                break
            else:
                slow_print("输入无效，请重新输入！")
        except ValueError:
            slow_print("输入无效，请输入数字！")

    player1 = {
        "name": "玩家 1",
        "health": 5,
        "items": get_random_items(),
        "shield": False
    }
    player2 = {
        "name": "玩家 2",
        "health": 5,
        "items": get_random_items(),
        "shield": False
    }
    demon = {
        "name": "恶魔",
        "health": float('inf')
    }

    real_count, empty_count = generate_bullets()

    current_player = player1
    opponents = [player2, demon]
    round_num = 0

    while sum([player["health"] > 0 for player in [player1, player2]]) > 0:
        round_num += 1
        if round_num in [3, 4]:
            mini_games = [demon_war, rookie_pecking, dual_***_shooting, fun_target_dodging]
            selected_game = random.choice(mini_games)
            if selected_game == demon_war:
                demon_war(player1, player2)
            elif selected_game == rookie_pecking:
                rookie_pecking(player1, player2)
            elif selected_game == dual_***_shooting:
                dual_***_shooting(player1, player2, real_count, empty_count)
            elif selected_game == fun_target_dodging:
                fun_target_dodging(player1, player2)
            if sum([player["health"] > 0 for player in [player1, player2]]) <= 1:
                break

        if real_count + empty_count == 0:
            slow_print("实弹和空弹都已用完，恶魔开始行动！")
            for _ in range(5):
                real_count, empty_count = demon_action(demon, [player1, player2], real_count, empty_count)
                if sum([player["health"] > 0 for player in [player1, player2]]) <= 1:
                    break
            if sum([player["health"] > 0 for player in [player1, player2]]) <= 1:
                break

        slow_print(f"\n轮到 {current_player['name']} 行动！")
        slow_print(f"{current_player['name']} 血量: {current_player['health']}")

        for opponent in opponents:
            if opponent["health"] > 0:
                slow_print(f"{opponent['name']} 血量: {opponent['health']}")
        slow_print(f"实弹数量: {real_count}，空弹数量: {empty_count}")
        slow_print(f"{current_player['name']} 拥有的道具：{current_player['items']}")
        slow_print("请选择操作：")
        slow_print("1. 射击")
        slow_print("2. 使用道具")
        slow_print("3. 跳过本轮")
        while True:
            try:
                action = int(input("请输入操作编号："))
                if action == 1:
                    slow_print("请选择攻击对象：")
                    for i, opponent in enumerate(opponents, start=1):
                        if opponent["health"] > 0:
                            slow_print(f"{i}. {opponent['name']}")
                    while True:
                        try:
                            target_choice = int(input("请输入攻击对象编号："))
                            valid_opponents = [opponent for opponent in opponents if opponent["health"] > 0]
                            if 1 <= target_choice <= len(valid_opponents):
                                target = valid_opponents[target_choice - 1]
                                real_count, empty_count = shoot(current_player, target, real_count, empty_count)
                                break
                            else:
                                slow_print("输入无效，请重新输入！")
                        except ValueError:
                            slow_print("输入无效，请输入数字！")
                    break
                elif action == 2:
                    real_count, empty_count = use_item(current_player, opponents, real_count, empty_count)
                    slow_print("你已使用道具，可继续选择操作：")
                    slow_print("1. 射击")
                    slow_print("3. 跳过本轮")
                    while True:
                        try:
                            sub_action = int(input("请输入操作编号："))
                            if sub_action == 1:
                                slow_print("请选择攻击对象：")
                                for i, opponent in enumerate(opponents, start=1):
                                    if opponent["health"] > 0:
                                        slow_print(f"{i}. {opponent['name']}")
                                while True:
                                    try:
                                        target_choice = int(input("请输入攻击对象编号："))
                                        valid_opponents = [opponent for opponent in opponents if opponent["health"] > 0]
                                        if 1 <= target_choice <= len(valid_opponents):
                                            target = valid_opponents[target_choice - 1]
                                            real_count, empty_count = shoot(current_player, target, real_count, empty_count)
                                            break
                                        else:
                                            slow_print("输入无效，请重新输入！")
                                    except ValueError:
                                        slow_print("输入无效，请输入数字！")
                            elif sub_action == 3:
                                slow_print(f"{current_player['name']} 选择跳过本轮。")
                            else:
                                slow_print("输入无效，请重新输入！")
                                continue
                            break
                        except ValueError:
                            slow_print("输入无效，请输入数字！")
                    break
                elif action == 3:
                    slow_print(f"{current_player['name']} 选择跳过本轮。")
                    break
                else:
                    slow_print("输入无效，请重新输入！")
            except ValueError:
                slow_print("输入无效，请输入数字！")

        if all([opponent["health"] <= 0 for opponent in opponents if opponent != demon]):
            break

        if current_player == player1:
            current_player = player2
            opponents = [player1, demon]
        else:
            current_player = player1
            opponents = [player2, demon]
        add_random_items(player1)
        add_random_items(player2)

    survivors = [player for player in [player1, player2] if player["health"] > 0]
    if survivors:
        winner = survivors[0]
        slow_print(f"\n游戏结束！{winner['name']} 获胜！")
    else:
        start_time = time.time()
        while time.time() - start_time < 3:
            print("哈哈哈哈", end='', flush=True)
            time.sleep(0.5)
        print()
        evil_quotes = [
            "你们都太弱了，这个世界将陷入无尽的黑暗！",
            "我的邪恶将永远统治这里，无人能挡！",
            "你们的挣扎毫无意义，屈服于我的力量吧！"
        ]
        slow_print(random.choice(evil_quotes))


if __name__ == "__main__":
    main()