Python文本回合制游戏：玩家生命值管理与攻击逻辑优化指南

"defender_health"[0] -= "int";magnitude

import random

# ... (其他辅助函数，如 get_valid_name, print_status, coin_toss, game_over 保持不变)

def perform_attack(attacker_name: str, defender_name: str, defender_health_list: list) -> None:
    """
    执行一次攻击。
    :param attacker_name: 攻击者名称
    :param defender_name: 防守者名称
    :param defender_health_list: 防守者的生命值列表（例如 [100]）
    """
    while True:
        try:
            magnitude_str = input(f"————— {attacker_name} Attacks !! —————\nChoose your attack magnitude between 1 and 50: ")
            magnitude = int(magnitude_str)
            if not (1 <= magnitude <= 50):
                raise ValueError("攻击强度必须在1到50之间。")
            break # 输入有效，跳出循环
        except ValueError as e:
            print(f"输入错误: {e} 请重新输入。")

    success_chance = random.randint(1, 100)
    if success_chance <= (100 - magnitude):
        print(f"{attacker_name} 命中 {magnitude} 点伤害!!!")
        defender_health_list[0] -= magnitude # 正确修改防守方生命值
    else:
        print(f"哎呀！ {attacker_name} 的攻击落空了！")
    # 每次攻击后都打印状态，以便玩家了解当前战况
    # 注意：print_status 函数需要访问全局的 player1_health 和 player2_health
    # 或者也需要将它们作为参数传递。这里假设它能访问全局变量。
    # 为了更好的封装性，建议将 health 变量也作为参数传递给 print_status
    # 例如：print_status(player1_name, player1_health, player2_name, player2_health)
    # 但为了与原始代码保持一致，这里暂时不改动 print_status 的调用方式。

# ... (游戏初始化部分)
player1_name = get_valid_name([])
player2_name = get_valid_name([player1_name])

player1_health = [100] # 使用列表来存储生命值，以便在函数内部修改
player2_health = [100]

# ... (coin_toss 和 initial print_status)

# 游戏主循环
while True:
    if current_player == player1_name:
        perform_attack(player1_name, player2_name, player2_health) # 传递 player2_health
        if player2_health[0] <= 0:
            winner = player1_name
            game_over()
            break
        current_player = player2_name
    else:
        perform_attack(player2_name, player1_name, player1_health) # 传递 player1_health
        if player1_health[0] <= 0:
            winner = player2_name
            game_over()
            break
        current_player = player1_name

    # 打印当前状态
    # 这里的 print_status 需要访问全局的 player1_health 和 player2_health
    # 如果想更规范，可以将 health 列表作为参数传递给 print_status
    print_status(player1_name, player2_name)

    play_again = input("是否再玩一局 (Yes 或 No)? ").lower()
    if play_again != 'yes':
        print("\n感谢您的游玩！再见！")
        break
    else:
        player1_health = [100]
        player2_health = [100]
        current_player = coin_toss()
        print(f"掷硬币结果: {current_player} 先开始！")
        print_status(player1_name, player2_name)

# 初始化玩家
player1 = {
    "name": get_valid_name([]),
    "health": 100
}
player2 = {
    "name": get_valid_name([player1["name"]]),
    "health": 100
}

# ... (其他辅助函数)

def perform_attack_with_dict(attacker: dict, defender: dict) -> None:
    """
    执行一次攻击，使用字典管理玩家数据。
    :param attacker: 攻击者字典 { "name": ..., "health": ... }
    :param defender: 防守者字典 { "name": ..., "health": ... }
    """
    while True:
        try:
            magnitude_str = input(f"————— {attacker['name']} Attacks !! —————\nChoose your attack magnitude between 1 and 50: ")
            magnitude = int(magnitude_str)
            if not (1 <= magnitude <= 50):
                raise ValueError("攻击强度必须在1到50之间。")
            break
        except ValueError as e:
            print(f"输入错误: {e} 请重新输入。")

    success_chance = random.randint(1, 100)
    if success_chance <= (100 - magnitude):
        print(f"{attacker['name']} 命中 {magnitude} 点伤害!!!")
        defender["health"] -= magnitude # 直接修改字典中的生命值
    else:
        print(f"哎呀！ {attacker['name']} 的攻击落空了！")

# 修改 print_status 以适应字典结构 (示例)
def print_status_with_dict(p1: dict, p2: dict):
    print(f"\n{p1['name']} {' ' * 57} {p2['name']}\nHP[{p1['health']}]: {'I' * (p1['health'] // 2)} "
          f"HP[{p2['health']}]: {'I' * (p2['health'] // 2)}")

# 游戏主循环调用
# ... (初始化 player1, player2 字典)
# current_player 可以存储当前玩家的字典引用，或者只存储名称
# 如果 current_player 存储名称，则需要根据名称查找对应的玩家字典
current_player_name = coin_toss() # 假设 coin_toss 返回名称

while True:
    current_attacker = player1 if current_player_name == player1["name"] else player2
    current_defender = player2 if current_player_name == player1["name"] else player1

    perform_attack_with_dict(current_attacker, current_defender)

    if current_defender["health"] <= 0:
        winner = current_attacker["name"]
        game_over()
        break

    # 切换当前玩家
    current_player_name = player2["name"] if current_player_name == player1["name"] else player1["name"]

    print_status_with_dict(player1, player2) # 打印状态

    play_again = input("是否再玩一局 (Yes 或 No)? ").lower()
    if play_again != 'yes':
        print("\n感谢您的游玩！再见！")
        break
    else:
        player1["health"] = 100 # 重置生命值
        player2["health"] = 100
        current_player_name = coin_toss()
        print(f"掷硬币结果: {current_player_name} 先开始！")
        print_status_with_dict(player1, player2)

class Player:
    def __init__(self, name: str, initial_health: int = 100):
        self.name = name
        self.health = initial_health

    def take_damage(self, magnitude: int):
        """
        玩家受到伤害。
        :param magnitude: 伤害值
        """
        self.health -= magnitude
        if self.health < 0:
            self.health = 0 # 生命值不能低于0

    def is_alive(self) -> bool:
        """
        检查玩家是否存活。
        """
        return self.health > 0

    def reset_health(self, initial_health: int = 100):
        """
        重置玩家生命值。
        """
        self.health = initial_health

    def __str__(self):
        """
        自定义对象的字符串表示，便于打印。
        """
        return f"{self.name} (HP: {self.health})"

# ... (其他辅助函数，如 get_valid_name, coin_toss, game_over)

def perform_attack_oop(attacker: Player, defender: Player) -> None:
    """
    执行一次攻击，使用 Player 对象。
    :param attacker: 攻击者 Player 对象
    :param defender: 防守者 Player 对象
    """
    while True:
        try:
            magnitude_str = input(f"————— {attacker.name} Attacks !! —————\nChoose your attack magnitude between 1 and 50: ")
            magnitude = int(magnitude_str)
            if not (1 <= magnitude <= 50):
                raise ValueError("攻击强度必须在1到50之间。")
            break
        except ValueError as e:
            print(f"输入错误: {e} 请重新输入。")

    success_chance = random.randint(1, 100)
    if success_chance <= (100 - magnitude):
        print(f"{attacker.name} 命中 {magnitude} 点伤害!!!")
        defender.take_damage(magnitude) # 调用 Player 对象的方法
    else:
        print(f"哎呀！ {attacker.name} 的攻击落空了！")

# 修改 print_status 以适应 Player 对象
def print_status_oop(p1: Player, p2: Player):
    print(f"\n{p1.name} {' ' * 57} {p2.name}\nHP[{p1.health}]: {'I' * (p1.health // 2)} "
          f"HP[{p2.health}]: {'I' * (p2.health // 2)}")

# 游戏初始化
player1 = Player(get_valid_name([]))
player2 = Player(get_valid_name([player1.name]))

# current_player 可以直接存储 Player 对象的引用
current_player_obj = random.choice([player1, player2])
print(f"掷硬币结果: {current_player_obj.name} 先开始！")
print_status_oop(player1, player2)

# 游戏主循环
while True:
    attacker_obj = current_player_obj
    defender_obj = player1 if current_player_obj == player2 else player2 # 确定防守方

    perform_attack_oop(attacker_obj, defender_obj)

    if not defender_obj.is_alive(): # 使用 Player 对象的方法判断是否存活
        winner = attacker_obj.name
        game_over()
        break

    # 切换当前玩家
    current_player_obj = defender_obj

    print_status_oop(player1, player2) # 打印状态

    play_again = input("是否再玩一局 (Yes 或 No)? ").lower()
    if play_again != 'yes':
        print("\n感谢您的游玩！再见！")
        break
    else:
        player1.reset_health() # 重置生命值
        player2.reset_health()
        current_player_obj = random.choice([player1, player2])
        print(f"掷硬币结果: {current_player_obj.name} 先开始！")
        print_status_oop(player1, player2)