恶魔之轮 5.0 版本
2025-02-08 16:44:05
发布于：浙江
176阅读
8回复
5点赞
更新：更新bug，并且支持自己向自己设计
我希望 5.0 版本并没有人继续篡改他了，你们有没有想过我修复代码的困难？就篡改他！
恶魔之轮 5.0 代码
import time
import random
def slow_print(text, delay=0.000001):
"""以较慢速度逐字打印文本，模拟字幕效果"""
for char in text:
print(char, end='', flush=True)
time.sleep(delay)
print()
def introduce_rules():
"""介绍游戏规则"""
time.sleep(1)
slow_print("希望不要再有人篡改我的代码，请明白我修复代码的困难，感谢各位的配合")
time.sleep(1)
slow_print("原创作者:𝒹𝓇ℯ𝒶𝓂转载请表明原作者")
time.sleep(5)
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("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("后续情节规则：")
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
for _ in range(bullet_num):
if random.random() < real_count / (real_count + empty_count):
if isinstance(target, ComputerPlayer):
target.health -= 1
else:
target["health"] -= 1
slow_print(f"{shooter['name'] if not isinstance(shooter, ComputerPlayer) else shooter.name} 射出实弹，{target['name'] if not isinstance(target, ComputerPlayer) else target.name} 受到1点伤害！")
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):
"""使用道具的逻辑"""
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 -= 1
else:
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 -= damage
else:
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("输入无效，请输入数字！")
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:
continue
else:
if current_player["health"] <= 0:
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'] if not isinstance(current_player, ComputerPlayer) else 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'] if not isinstance(current_player, ComputerPlayer) else current_player.name} 啄啄，{opponent['name']} 受到2点伤害！")
def dual_***_shooting(player1, player2, real_count, empty_count):
"""双枪设计小游戏"""
slow_print("双枪设计小游戏开始！玩家每次射击射出两颗子弹。")
current_player = player1
opponent = player2
while True:
if isinstance(current_player, ComputerPlayer):
if current_player.health <= 0:
pass
else:
if current_player["health"] <= 0:
pass
if isinstance(opponent, ComputerPlayer):
if opponent.health <= 0:
pass
else:
if opponent["health"] <= 0:
pass
if (isinstance(current_player, ComputerPlayer) and current_player.health <= 0) and (isinstance(opponent, ComputerPlayer) and opponent.health <= 0):
break
if (not isinstance(current_player, ComputerPlayer) and current_player["health"] <= 0) and (not isinstance(opponent, ComputerPlayer) and opponent["health"] <= 0):
break
if (isinstance(current_player, ComputerPlayer) and current_player.health <= 0) or (not isinstance(current_player, ComputerPlayer) and current_player["health"] <= 0):
current_player, opponent = opponent, current_player
continue
slow_print(f"\n轮到 {current_player['name'] if not isinstance(current_player, ComputerPlayer) else current_player.name} 行动！")
slow_print(f"{current_player['name'] if not isinstance(current_player, ComputerPlayer) else current_player.name} 血量: {current_player['health'] if not isinstance(current_player, ComputerPlayer) else current_player.health}")
slow_print(f"{opponent['name'] if not isinstance(opponent, ComputerPlayer) else opponent.name} 血量: {opponent['health'] if not isinstance(opponent, ComputerPlayer) else opponent.health}")
slow_print(f"实弹数量: {real_count}，空弹数量: {empty_count}")
items = current_player.items if isinstance(current_player, ComputerPlayer) else current_player["items"]
slow_print(f"{current_player['name'] if not isinstance(current_player, ComputerPlayer) else current_player.name} 拥有的道具：{items}")
slow_print("请选择操作：")
slow_print("1. 射击")
slow_print("2. 使用道具")
slow_print("3. 跳过本轮")
if isinstance(current_player, ComputerPlayer):
action = random.randint(1, 3)
slow_print(f"{current_player.name}（电脑）选择操作: {action}")
else:
while True:
try:
action = int(input("请输入操作编号："))
break
except ValueError:
slow_print("输入无效，请输入数字！")
if action == 1:
slow_print("请选择攻击对象：")
all_opponents = [opponent] + [current_player] if not isinstance(current_player, ComputerPlayer) else [opponent] + [current_player]
valid_opponents = [opp for opp in all_opponents if (isinstance(opp, ComputerPlayer) and opp.health > 0) or (not isinstance(opp, ComputerPlayer) and opp["health"] > 0)]
for i, opp in enumerate(valid_opponents, start=1):
slow_print(f"{i}. {opp['name'] if not isinstance(opp, ComputerPlayer) else opp.name}")
while True:
try:
target_choice = int(input("请输入攻击对象编号："))
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, bullet_num=2)
if isinstance(target, ComputerPlayer):
if target.health <= 0:
slow_print(f"{target.name} 血量归零，本轮结束。")
break
else:
if target["health"] <= 0:
slow_print(f"{target['name']} 血量归零，本轮结束。")
break
break
else:
slow_print("输入无效，请重新输入！")
except ValueError:
slow_print("输入无效，请输入数字！")
elif action == 2:
real_count, empty_count = use_item(current_player, [opponent], real_count, empty_count)
slow_print("你已使用道具，可继续选择操作：")
slow_print("1. 射击")
slow_print("3. 跳过本轮")
if isinstance(current_player, ComputerPlayer):
sub_action = random.randint(1, 3)
if sub_action == 3:
slow_print(f"{current_player.name}（电脑）选择跳过本轮。")
elif sub_action == 1:
slow_print("请选择攻击对象：")
all_opponents = [opponent] + [current_player] if not isinstance(current_player, ComputerPlayer) else [opponent] + [current_player]
valid_opponents = [opp for opp in all_opponents if (isinstance(opp, ComputerPlayer) and opp.health > 0) or (not isinstance(opp, ComputerPlayer) and opp["health"] > 0)]
for i, opp in enumerate(valid_opponents, start=1):
slow_print(f"{i}. {opp['name'] if not isinstance(opp, ComputerPlayer) else opp.name}")
while True:
try:
target_choice = int(input("请输入攻击对象编号："))
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, bullet_num=2)
if isinstance(target, ComputerPlayer):
if target.health <= 0:
slow_print(f"{target.name} 血量归零，本轮结束。")
break
else:
if target["health"] <= 0:
slow_print(f"{target['name']} 血量归零，本轮结束。")
break
break
else:
slow_print("输入无效，请重新输入！")
except ValueError:
slow_print("输入无效，请输入数字！")
else:
while True:
try:
sub_action = int(input("请输入操作编号："))
if sub_action == 1:
slow_print("请选择攻击对象：")
all_opponents = [opponent] + [current_player] if not isinstance(current_player, ComputerPlayer) else [opponent] + [current_player]
valid_opponents = [opp for opp in all_opponents if (isinstance(opp, ComputerPlayer) and opp.health > 0) or (not isinstance(opp, ComputerPlayer) and opp["health"] > 0)]
for i, opp in enumerate(valid_opponents, start=1):
slow_print(f"{i}. {opp['name'] if not isinstance(opp, ComputerPlayer) else opp.name}")
while True:
try:
target_choice = int(input("请输入攻击对象编号："))
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, bullet_num=2)
if isinstance(target, ComputerPlayer):
if target.health <= 0:
slow_print(f"{target.name} 血量归零，本轮结束。")
break
else:
if target["health"] <= 0:
slow_print(f"{target['name']} 血量归零，本轮结束。")
break
break
else:
slow_print("输入无效，请重新输入！")
except ValueError:
slow_print("输入无效，请输入数字！")
elif sub_action == 3:
slow_print(f"{current_player['name'] if not isinstance(current_player, ComputerPlayer) else current_player.name} 选择跳过本轮。")
break
else:
slow_print("输入无效，请重新输入！")
except ValueError:
slow_print("输入无效，请输入数字！")
elif action == 3:
slow_print(f"{current_player['name'] if not isinstance(current_player, ComputerPlayer) else current_player.name} 选择跳过本轮。")
current_player, opponent = opponent, current_player
def fun_target_dodging(player1, player2):
"""趣味躲靶小游戏"""
slow_print("趣味躲靶小游戏开始！")
directions = ["上", "下", "左", "右"]
for current_player in [player1, player2]:
if isinstance(current_player, ComputerPlayer):
if current_player.health <= 0:
continue
else:
if current_player["health"] <= 0:
continue
if isinstance(current_player, ComputerPlayer):
dodge_direction = random.choice(directions)
slow_print(f"{current_player.name}（电脑）选择躲避方向: {dodge_direction}")
else:
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:
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点伤害！")
else:
slow_print(f"{current_player['name'] if not isinstance(current_player, ComputerPlayer) else current_player.name} 躲避成功！")
def mystery_messenger(players):
"""神秘信使情节"""
slow_print("你偶然遇到了一个神秘的信使，他递给你一封来自未知发件人的信件。")
slow_print("信件内容暗示了恶魔之轮背后隐藏着一个更大的阴谋，而你被选中来揭开这个秘密。")
tasks = [
"在危险的区域寻找古老的符文",
"与隐藏在暗处的神秘人物交流"
]
for task in tasks:
slow_print(f"信使要求你去 {task}。")
success_chance = random.randint(1, 10)
if success_chance > 3:
slow_print(f"你成功完成了 {task}，获得了一条关于阴谋的线索。")
else:
slow_print(f"你在 {task} 时失败了，游戏结束。")
return False
return True
def memory_fragments(players):
"""记忆碎片情节"""
total_fragments = 3
fragments_found = 0
slow_print("你在探索恶魔之轮的世界时，发现了一些神秘的记忆碎片。")
slow_print("这些碎片属于一个曾经试图阻止恶魔之轮转动的英雄，但他的记忆被邪恶力量分割。")
while fragments_found < total_fragments:
find_chance = random.randint(1, 10)
if find_chance > 4:
fragments_found += 1
slow_print(f"你找到了第 {fragments_found} 片记忆碎片，解锁了一段关于英雄的回忆。")
# 这里可以根据碎片数量添加不同的回忆内容
if fragments_found == 1:
slow_print("回忆中，英雄与恶魔展开了激烈的战斗，他挥舞着宝剑，毫不畏惧。")
elif fragments_found == 2:
slow_print("英雄和同伴们并肩作战，他们相互配合，共同对抗邪恶力量。")
elif fragments_found == 3:
slow_print("然而，最终英雄还是失败了，恶魔之轮的力量太过强大。")
else:
slow_print("你这次没有找到记忆碎片。")
danger_chance = random.randint(1, 10)
if danger_chance < 3:
slow_print("你在寻找碎片时遭遇了危险，任务失败，游戏结束。")
return False
slow_print("你成功收集齐了所有记忆碎片，了解到了恶魔之轮的一些弱点。")
return True
def hidden_cult(players):
"""隐藏教派情节"""
slow_print("你发现了一个隐藏的教派，他们秘密崇拜着恶魔之轮的力量。")
slow_print("教派成员分散在各个角落，通过秘密仪式和符号来传递信息。")
slow_print("你需要深入调查这个教派，了解他们的目的和计划。")
guardians_count = 2
while guardians_count > 0:
slow_print(f"你遇到了教派的守护者，准备应对挑战。")
success_chance = random.randint(1, 10)
if success_chance > 4:
slow_print("你成功突破了守护者的防线。")
guardians_count -= 1
else:
slow_print("你未能突破守护者的防线，游戏结束。")
return False
slow_print("你成功接近了教派的核心，准备与教派首领对决。")
boss_success_chance = random.randint(1, 10)
if boss_success_chance > 5:
slow_print("你击败了教派首领，成功揭开了教派的阴谋。")
return True
else:
slow_print("你在与教派首领的对决中失败了，游戏结束。")
return False
def time_space_rift(players):
"""时空裂缝情节"""
slow_print("在游戏的某个关键节点，你触发了一个神秘的事件，导致时空裂缝出现。")
slow_print("这些裂缝连接着不同的时间和空间，里面隐藏着各种危险和机遇。")
worlds_to_explore = 2
while worlds_to_explore > 0:
slow_print(f"你进入了第 {3 - worlds_to_explore} 个时空裂缝世界。")
time_anomaly_chance = random.randint(1, 10)
if time_anomaly_chance < 3:
slow_print("时间流动变得异常，给你带来了一些麻烦。")
treasure_chance = random.randint(1, 10)
if treasure_chance > 6:
slow_print("你在裂缝中找到了强大的道具和技能。")
enemy_chance = random.randint(1, 10)
if enemy_chance > 3:
slow_print("你遇到了裂缝中的敌人，开始战斗。")
fight_success_chance = random.randint(1, 10)
if fight_success_chance > 4:
slow_print("你成功击败了敌人。")
else:
slow_print("你在与敌人的战斗中失败了，游戏结束。")
return False
worlds_to_explore -= 1
slow_print("你成功探索完所有时空裂缝，获得了强大的助力。")
return True
def companion_betrayal(players):
"""同伴背叛情节"""
if len(players) < 2:
slow_print("由于当前是单人游戏，不会触发同伴背叛情节。")
return True
slow_print("你结识了一位强大的同伴，你们一起并肩作战。")
betrayal_chance = random.randint(1, 10)
if betrayal_chance > 3:
slow_print("然而，同伴突然背叛了你，他被恶魔的力量所诱惑。")
slow_print("你需要在被背叛的困境中寻找出路，躲避同伴的追杀并揭露他的阴谋。")
evade_chance = random.randint(1, 10)
if evade_chance > 4:
slow_print("你成功躲避了同伴的追杀。")
expose_chance = random.randint(1, 10)
if expose_chance > 5:
slow_print("你揭露了同伴的阴谋并阻止了他。")
return True
else:
slow_print("你未能揭露同伴的阴谋，游戏结束。")
return False
else:
slow_print("你没能躲避同伴的追杀，游戏结束。")
return False
else:
slow_print("同伴始终与你并肩作战，没有背叛你。")
return True
class ComputerPlayer:
def __init__(self, name):
self.name = name
self.health = 5
self.items = get_random_items()
self.shield = False
def choose_action(self, opponents, real_count, empty_count):
# 电脑玩家的行动策略：优先使用小烟回血，然后优先射击
if "小烟" in self.items and self.health < 5:
self.items.remove("小烟")
self.health = min(self.health + 1, 5)
slow_print(f"{self.name}（电脑）使用小烟，恢复1点血量，当前血量：{self.health}。")
return real_count, empty_count
elif real_count + empty_count > 0:
all_opponents = opponents + [self]
valid_opponents = [opp for opp in all_opponents if (isinstance(opp, ComputerPlayer) and opp.health > 0) or (not isinstance(opp, ComputerPlayer) and opp["health"] > 0)]
if valid_opponents:
target = random.choice(valid_opponents)
real_count, empty_count = shoot(self, target, real_count, empty_count)
return real_count, empty_count
slow_print(f"{self.name}（电脑）选择跳过本轮。")
return real_count, empty_count
def main():
slow_print("欢迎来到恶魔之轮游戏！")
introduce_rules()
while True:
try:
mode_choice = int(input("请选择游戏模式（1. 玩家对战；2. 人机对战）："))
if mode_choice == 1 or mode_choice == 2:
break
else:
slow_print("输入无效，请重新输入！")
except ValueError:
slow_print("输入无效，请输入数字！")
if mode_choice == 1:
player1 = {
"name": "玩家1",
"health": 5,
"items": get_random_items(),
"shield": False
}
player2 = {
"name": "玩家2",
"health": 5,
"items": get_random_items(),
"shield": False
}
else:
player1 = {
"name": "玩家1",
"health": 5,
"items": get_random_items(),
"shield": False
}
player2 = ComputerPlayer("电脑玩家")
demon = {
"name": "恶魔",
"health": float('inf')
}
real_count, empty_count = generate_bullets()
current_player = player1
opponents = [player2, demon]
round_num = 0
while True:
survivors = [player for player in [player1, player2] if (isinstance(player, ComputerPlayer) and player.health > 0) or (not isinstance(player, ComputerPlayer) and player["health"] > 0)]
if len(survivors) <= 1:
break
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 real_count + empty_count == 0:
slow_print("实弹和空弹都已用完，恶魔开始行动！")
for _ in range(5):
real_count, empty_count = demon_action(demon, [player1, player2], real_count, empty_count)
survivors = [player for player in [player1, player2] if (isinstance(player, ComputerPlayer) and player.health > 0) or (not isinstance(player, ComputerPlayer) and player["health"] > 0)]
if len(survivors) <= 1:
break
if len(survivors) <= 1:
break
slow_print(f"\n轮到 {current_player['name'] if not isinstance(current_player, ComputerPlayer) else current_player.name} 行动！")
slow_print(f"{current_player['name'] if not isinstance(current_player, ComputerPlayer) else current_player.name} 血量: {current_player['health'] if not isinstance(current_player, ComputerPlayer) else current_player.health}")
for opponent in opponents:
if isinstance(opponent, ComputerPlayer):
if opponent.health > 0:
slow_print(f"{opponent.name} 血量: {opponent.health}")
else:
if opponent["health"] > 0:
slow_print(f"{opponent['name']} 血量: {opponent['health']}")
slow_print(f"实弹数量: {real_count}，空弹数量: {empty_count}")
items = current_player.items if isinstance(current_player, ComputerPlayer) else current_player["items"]
slow_print(f"{current_player['name'] if not isinstance(current_player, ComputerPlayer) else current_player.name} 拥有的道具：{items}")
slow_print("请选择操作：")
slow_print("1. 射击")
slow_print("2. 使用道具")
slow_print("3. 跳过本轮")
if isinstance(current_player, ComputerPlayer):
real_count, empty_count = current_player.choose_action(opponents, real_count, empty_count)
else:
while True:
try:
action = int(input("请输入操作编号："))
if action == 1:
slow_print("请选择攻击对象：")
all_opponents = opponents + [current_player]
valid_opponents = [opp for opp in all_opponents if (isinstance(opp, ComputerPlayer) and opp.health > 0) or (not isinstance(opp, ComputerPlayer) and opp["health"] > 0)]
for i, opp in enumerate(valid_opponents, start=1):
slow_print(f"{i}. {opp['name'] if not isinstance(opp, ComputerPlayer) else opp.name}")
while True:
try:
target_choice = int(input("请输入攻击对象编号："))
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("请选择攻击对象：")
all_opponents = opponents + [current_player]
valid_opponents = [opp for opp in all_opponents if (isinstance(opp, ComputerPlayer) and opp.health > 0) or (not isinstance(opp, ComputerPlayer) and opp["health"] > 0)]
for i, opp in enumerate(valid_opponents, start=1):
slow_print(f"{i}. {opp['name'] if not isinstance(opp, ComputerPlayer) else opp.name}")
while True:
try:
target_choice = int(input("请输入攻击对象编号："))
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 sub_action == 3:
slow_print(f"{current_player['name']} 选择跳过本轮。")
break
else:
slow_print("输入无效，请重新输入！")
except ValueError:
slow_print("输入无效，请输入数字！")
break
elif action == 3:
slow_print(f"{current_player['name']} 选择跳过本轮。")
break
else:
slow_print("输入无效，请重新输入！")
except ValueError:
slow_print("输入无效，请输入数字！")
survivors = [player for player in [player1, player2] if (isinstance(player, ComputerPlayer) and player.health > 0) or (not isinstance(player, ComputerPlayer) and player["health"] > 0)]
if len(survivors) <= 1:
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 (isinstance(player, ComputerPlayer) and player.health > 0) or (not isinstance(player, ComputerPlayer) and player["health"] > 0)]
if survivors:
winner = survivors[0]
slow_print(f"\n恶魔之轮游戏结束！{winner['name'] if not isinstance(winner, ComputerPlayer) else winner.name} 获胜！")
if len(survivors) == 1 and not isinstance(winner, ComputerPlayer):
while True:
save_choice = input(f"{winner['name']}，你是否要救另一位玩家？(输入Y或N)：").strip().upper()
if save_choice == 'Y':
loser = player1 if winner == player2 else player2
if isinstance(loser, ComputerPlayer):
loser.health = 5
else:
loser["health"] = 5
slow_print(f"你成功救起了 {loser['name'] if not isinstance(loser, ComputerPlayer) else loser.name}，接下来将以两人模式继续游戏。")
players = [winner, loser]
break
elif save_choice == 'N':
slow_print("你选择不救另一位玩家，接下来将以单人模式继续游戏。")
players = [winner]
break
else:
slow_print("输入无效，请重新输入！")
else:
players = survivors
# 后续情节
plots = [mystery_messenger, memory_fragments, hidden_cult, time_space_rift, companion_betrayal]
for plot in plots:
result = plot(players)
if not result:
slow_print("很遗憾，你在游戏中失败了，游戏结束。")
return
slow_print("恭喜你，你成功完成了所有情节，揭开了恶魔之轮背后的巨大阴谋，拯救了世界！游戏通关！")
else:
slow_print("哎呀，两位玩家都失败了，恶魔得逞了！游戏结束。")
if __name__ == "__main__":
main()
有帮助，赞一个