重构gam的“to-hit”值

Question

我在做一个游戏，其中一个方法是根据技能值计算角色的基本命中数。该方法目前单独计算每个值，因为每种技能都可以用于短距离、中距离和长距离。在

我最初以为我可以将这些技能组合成一个元组并在其上迭代，动态地创建每个命中数。但我不知道是否真的有可能，因为我现在已经将每个命中数分配给了它自己的变量。在

我还考虑为每个范围创建一个方法，并将元组作为参数传递。我可以用结果值创建一个新的元组或列表，然后将它们分配给各个变量，但我不认为这样做比这样做更好，只是看起来不像是复制粘贴。在

以下是我目前的情况：

    def calcBaseHitNumbers(self, dict):
        """Calculate character's base hit numbers depending on skill level."""

        self.skill_dict = dict

        self.rifle = self.skill_dict.get('CRM', 0)
        self.pistol = self.skill_dict.get('PST', 0)
        self.big_gun = self.skill_dict.get('LCG', 0)
        self.heavy_weapon = self.skill_dict.get('HW', 0)
        self.bow = self.skill_dict.get('LB', 0)
        #self.skill_tuple = (self.rifle, self.pistol, self.big_gun, self.heavy_weapon,
        #    self.bow)

#---Short range
##        for skill in self.skill_tuple:
##            self.base_hit_short = skill * 0.6
        self.charAttribs.bhCRM_short = self.rifle * 0.6
        self.charAttribs.bhPST_short = self.pistol * 0.6
        self.charAttribs.bhHW_short = self.heavy_weapon * 0.6
        self.charAttribs.bhLCG_short = self.big_gun * 0.6
        self.charAttribs.bhLB_short = self.bow * 0.6
#---Med range
        self.charAttribs.bhCRM_med = self.rifle * 0.3
        self.charAttribs.bhPST_med = self.pistol * 0.3
        self.charAttribs.bhHW_med = self.heavy_weapon * 0.3
        self.charAttribs.bhLCG_med = self.big_gun * 0.3
        self.charAttribs.bhLB_med = self.bow * 0.3
#---Long range
        self.charAttribs.bhCRM_long = self.rifle * 0.1
        self.charAttribs.bhPST_long = self.pistol * 0.1
        self.charAttribs.bhHW_long = self.heavy_weapon * 0.1
        self.charAttribs.bhLCG_long = self.big_gun * 0.1
        self.charAttribs.bhLB_long = self.bow * 0.1

你如何重构它使它更具动态性？在

---

编辑：我想我想做的是： 有一个元组（就像我注释过的那个）并迭代3次，每次根据每个特定范围的修饰符生成一个新值（针对每个技能）。结果值会自动分配给它各自的变量。在

在我看来，这是有道理的。但当我真的试着编码的时候，我就迷路了。问题是，我想，这是我写的第一个“真正的”程序；我以前所做的只是一些小脚本。在

这只是我的程序的0.1版本，所以现在重构它并不重要。然而，这似乎是非常不符合Python的手动操作，我也希望“未来证明”这一点，以防未来的事情发生变化。在

Answer 1

感觉你真正想要的是一个代表武器的类，有处理基本值和使用各种修饰符计算命中值的属性。下面是一个简单的例子：

SHORT_RANGE = 'S'
MEDIUM_RANGE = 'M'
LONG_RANGE = 'L'
SHORT_RANGE_MODIFIER = 0.6
MEDIUM_RANGE_MODIFIER = 0.3
LONG_RANGE_MODIFIER = 0.1

class Weapon(object):
    def __init__(self, code_name, full_name, base_hit_value,
                 short_range_modifier=None, medium_range_modifier=None,
                 long_range_modifier=None):
        self.code_name, self.full_name = code_name, full_name
        self.base_hit_value = base_hit_value
        self.range_modifiers = {
            SHORT_RANGE: short_range_modifier or SHORT_RANGE_MODIFIER,
            MEDIUM_RANGE: medium_range_modifier or MEDIUM_RANGE_MODIFIER,
            LONG_RANGE: long_range_modifier or LONG_RANGE_MODIFIER,
        }

    def hit_value(self, range, modifier=1):
        return self.base_hit_value * self.range_modifiers[range] * modifier

从那里，您可以在角色对象内创建武器实例，如下所示：

^{pr2}$

然后如果，比如说，角色在近距离发射手枪：

    hit_value = self.pistol.hit_value(SHORT_RANGE)

hit_value（）方法的额外参数可用于传递特定于字符或情况的修改。在

当然，除此之外的下一步将是直接将武器建模为武器的子类（也许可以分解为特定类型的武器，如枪支、弓、手榴弹等，每个都有自己的基本值），并添加一个库存类来表示角色携带的武器。在

所有这些都是相当标准的、无聊的面向对象的设计过程，但是对于很多情况，这种类型的思考会让您快速起步，并提供至少一点基本的灵活性。在

Answer 2

让我们看看我是否理解你的场景：每种武器都有自己独特的生命值，因此步枪可能有1，重型武器可能有2个等等。然后每个角色都有一个短、中、长值乘以武器的命中值。在

你应该考虑使用策略设计。那就是创建一个武器超类，具有命中点属性。为步枪、手枪、弓等制造次级武器。我确信这些武器之间的区别不仅仅是命中点。在

然后角色有一个或多个武器取决于你的游戏。计算特定武器的命中点很简单

current_weapon * self.medium

如果你决定以后添加更多的武器，那么你不必编辑你的角色代码，因为你的角色可以处理任何武器。在

在伪Python中

^{pr2}$

Answer 3

@Vinko:也许可以做calcBaseHitNumbers，做“如果没有”自计算基数：“内部检查，如果以前做过，就不做手术。也就是说，我看不出迫切需要预先计算这些信息。但我不是Python性能专家。在