为了优化战斗循环以避免不必要的重复，并提升代码的可读性，通常需要关注以下几个方面：
- 提取重复代码到函数中：将重复执行的代码块提取为函数，可以简化主逻辑并提高可读性和可维护性。
- 简化逻辑分支：避免嵌套的
if-else语句，使用简洁的逻辑表达。 - 确保状态可读和明确：用清晰的变量名和注释来说明每个状态，确保代码更易于理解。
我们可以通过一个简单的战斗循环示例来演示这些原则。假设我们有一个玩家与敌人进行回合制战斗的游戏。
1、问题背景
在给定的代码中，玩家可以为两个角色创建一个战斗游戏。游戏包括两个角色: Charone 和 Chartwo，都有力量和技能属性。玩家可以为每个属性输入值，然后游戏将计算他们的修改器，根据角色的差异，然后他们将掷骰子来确定谁赢得了回合。战斗循环将继续进行，直到其中一个角色的强度属性达到0，此时该角色死亡，游戏结束。
然而，在给定的代码中，存在重复代码，导致可读性差，维护困难。代码中，骰子滚动功能运行两次，这似乎是不必要的。此外，还有许多全局变量，导致代码难以阅读和理解。
2、解决方案
为了解决代码中的问题，改进战斗循环，使其变得更简洁和易读，具体改进措施包括：
- 消除重复代码：
- 将骰子滚动功能合并到一个函数中，只在代码中调用一次。
- 使用字典来存储角色的力量和技能信息，以便更轻松地访问和更新这些信息。
- 使用循环来迭代戰鬥回合，从而簡化 кода。
- 消除全局变量：
- 将所有全局变量移动到一个单独的类中，以便更轻松地管理和访问这些变量。
下面是改进后的代码：
import random
import time
import math
import sys
class Fighter:
def __init__(self, name, strength, skill):
self.name = name
self.strength = strength
self.skill = skill
def is_alive(self):
return self.strength > 0
def health_mod(self, other_fighter):
delta = abs(self.strength - other_fighter.strength)
return int(delta / 5)
def skill_mod(self, other_fighter):
delta = abs(self.skill - other_fighter.skill)
return int(delta / 5)
def attack(self, other_fighter):
# wait_for_enter("Hit Enter to fight!")
# figure out mod values
health_mod = self.health_mod(other_fighter)
skill_mod = self.skill_mod(other_fighter)
self_roll = roll()
other_roll = roll()
# slow_print(
# "Health mod: {} Skill mod: {} {} rolls {} {} rolls {}"
# .format(
# health_mod, skill_mod,
# self.name, self_roll,
# other_fighter.name, other_roll
# )
# )
# figure out who won this round
if self_roll == other_roll:
print("Draw! No damage done.")
else:
winner, loser = (self, other_fighter) if self_roll > other_roll else (other_fighter, self)
print("{} hits {}!".format(winner.name, loser.name))
winner.strength += health_mod
winner.skill += skill_mod
loser.strength -= health_mod
loser.skill -= skill_mod
# show results
print('')
print(self)
print(other_fighter)
print('')
def __str__(self):
return "{}: strength {}, skill {}".format(self.name, max(self.strength, 0), max(self.skill, 0))
def roll(die_sides=6):
return random.randint(1, die_sides)
def fight():
charone = Fighter("Charone", 60, 70)
chartwo = Fighter("Chartwo", 65, 75)
print("\n{} encounters {}\nBattle Initiated!".format(charone.name, chartwo.name))
while charone.is_alive() and chartwo.is_alive():
charone.attack(chartwo)
chartwo.attack(charone)
winner, loser = (charone, chartwo) if charone.is_alive() else (chartwo, charone)
print("{} has died; {} wins!".format(loser.name, winner.name))
def main():
while True:
fight()
if not get_tf("Would you like to play again? (Y/n)"):
print("Goodbye!")
break
if __name__ == "__main__":
main()- 注释：
- 在循环中使用
pause来添加延迟，以便用户可以看到正在发生的事情。 - 使用
slow_print将骰子掷骰的结果缓慢地打印出来，以便更具戏剧性。 - 使用
wait_for_enter函数来等待用户按回车键，这样他们才能在每个回合中继续前进。 - 将
charone_strength和chartwo_strength变量初始化为 60 和 65，并将charone_skill和chartwo_skill变量初始化为 70 和 75。 - 在
battle函数中，使用charone和chartwo对象来跟踪每个角色的属性，而不是使用全局变量。 - 代码示例：
roll函数：
def roll(die_sides=6):
return random.randint(1, die_sides)Fighter类：
class Fighter:
def __init__(self, name, strength, skill):
self.name = name
self.strength = strength
self.skill = skill
def is_alive(self):
return self.strength > 0
def health_mod(self, other_fighter):
delta = abs(self.strength - other_fighter.strength)
return int(delta / 5)
def skill_mod(self, other_fighter):
delta = abs(self.skill - other_fighter.skill)
return int(delta / 5)
def attack(self, other_fighter):
# wait_for_enter("Hit Enter to fight!")
# figure out mod values
health_mod = self.health_mod(other_fighter)
skill_mod = self.skill_mod(other_fighter)
self_roll = roll()
other_roll = roll()
print(
"Health mod: {} Skill mod: {} {} rolls {} {} rolls {}"
.format(
health_mod, skill_mod,
self.name, self_roll,
other_fighter.name, other_roll
)
)
# figure out who won this round
if self_roll == other_roll:
print("Draw! No damage done.")
else:
winner, loser = (self, other_fighter) if self_roll > other_roll else (other_fighter, self)
print("{} hits {}!".format(winner.name, loser.name))
winner.strength += health_mod
winner.skill += skill_mod
loser.strength -= health_mod
loser.skill -= skill_mod
# show results
print('')
print(self)
print(other_fighter)
print('')
def __str__(self):
return "{}: strength {}, skill {}".format(self.name, max(self.strength, 0), max(self.skill, 0))battle函数：
def battle(charone, chartwo):
global charone_strength
global charone_skill
global chartwo_strength
global chartwo_skill
if player1 == player2:
print("\nThis round is a draw! No damage done")
elif player1 > player2:
charone_strength = charone_str + str_mod
charone_skill = charone_skl + skl_mod
chartwo_strength = chartwo_skl - str_mod
chartwo_skill = chartwo_skl - skl_mod
print "\n"+charone+" won this round"
print "\n"+"Character 1:",charone
print "Strength:",charone_strength
print "Skill:",charone_skill
time.sleep(1)
print "\nCharacter 2:",chartwo
print "Strength:",chartwo_strength
print "Skill:",chartwo_skill
elif player2 > player1:
chartwo_strength = chartwo_str + str_mod
chartwo_skill = chartwo_skl + skl_mod
charone_strength = charone_str - str_mod
charone_skill = charone_skl - skl_mod
print "\n"+chartwo+" won this round"
print "\nCharacter 2:",chartwo
print "Strength改进后的战斗循环具有以下优势：
- 消除重复代码：通过提取doss逻辑到函数中，减少了冗余代码。
- 代码清晰、模块化：每个函数只做一件事情，使得代码更加易于理解和维护。
- 增强可扩展性：未来可以更容易地添加新功能和调整现有逻辑。
这种编写方式使代码更具可读性和灵活性，是对复杂战斗系统的一个良好开端。