1

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

我最初认为我可以将技能组合成一个元组并对其进行迭代，动态创建每个命中数。但我不知道这是否真的可能，因为我目前将每个命中数分配给它自己的变量。

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

这是我目前拥有的：

    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 版本，所以现在重构它并不重要。但是，手动执行此操作似乎非常不符合 Pythonic，我还想“面向未来”以防万一事情发生变化。

4

5 回答 5

6

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

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

从那里，您可以在 Character 对象中创建 Weapon 实例，如下所示：

    self.rifle = Weapon('CRM', 'rifle', 5)
    self.pistol = Weapon('PST', 'pistol', 10)

然后，如果角色在短距离内开枪：

    hit_value = self.pistol.hit_value(SHORT_RANGE)

hit_value() 方法的额外参数可用于传递特定于字符或情境的修改。

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

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

于 2008-10-26T11:42:26.163 回答
1

让我们看看我是否理解你的情况：每种武器都有自己不同的生命值，所以步枪可能有 1，重型武器可能有 2，等等。然后每个角色都有一个短、中、长值乘以生命值武器。

您应该考虑使用策略设计。那就是创建一个具有生命值属性的武器超类。为步枪、手枪、弓等创建子类武器。我确信武器之间的差异不仅仅是生命值。

然后角色根据您的游戏玩法拥有一种或多种武器。计算特定武器的生命值很简单

current_weapon * self.medium

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

在伪 Python 中

class Weapon
    hit = 1
    #other properties of weapon

class Rifle(Weapon)
    #other properties of Rifle

class Pistol(Weapon)
    #other properties of Pistol

class Character
   weapon = Rifle()
   long=0.6
   def calcHit()
      return self.long*weapon.hit

john = Character()
john.weapon= Rifle()
john.calcHit
于 2008-10-26T11:39:29.587 回答
0

@Vinko：也许制作calcBaseHitNumbers，在内部进行“如果不是self.calculatedBase：”检查，如果之前已经完成，则无需操作。也就是说，我看不到预先计算这些信息的迫切需要。但我不是 Python 性能专家。

于 2008-10-26T11:35:07.303 回答
0

你指的是什么动态感？可能会发生什么变化 - 技能的数量，或权重因素，范围的数量（短，中，长）或所有这些？

之后（例如） bhPST_* 值会发生什么 - 它们是否合并为一个数字？

突显出来的一件事是，技能列表是硬连线在代码中的——我倾向于用一种方法替换 bh 变量

所以（请考虑到我不知道关于 Python 的第一件事 :)）

def bh_short(self, key)
  skill = self.skill_dict.get(key, 0)
  return skill * 0.6

现在，您可以保留有助于生命值的技能列表并迭代调用 bh_short 等。

可能还将范围（long med short）传递给函数，或返回所有三个值 - 这完全取决于您接下来要使用计算的生命值做什么。

基本上，我们需要更多关于使用上下文的信息

于 2008-10-26T11:39:38.650 回答
0

我会有一个用于角色属性的类（所以你在角色类中没有一堆东西）和一个用于武器属性的类：

class WeaponAttribute(object):

    short_mod = 0.6
    med_mod = 0.3
    long_mod = 0.1

    def __init__(self, base):
        self.base = base

    @property
    def short(self):
        return self.base * self.short_mod

    @property
    def med(self):
        return self.base * self.med_mod

    @property
    def long(self):
        return self.base * self.long_mod


class CharacterAttributes(object):

    def __init__(self, attributes):
        for weapon, base in attributes.items():
            setattr(self, weapon, WeaponAttribute(base))

在字符类中有一个CharacterAttributes对象并像这样使用它：

# Initialise
self.charAttribs = CharacterAttributes(self.skill_dict)
# Get some values
print self.charAttribs.CRM.short
print self.charAttribs.PST.med
print self.charAttribs.LCG.long
于 2008-10-27T05:14:52.530 回答