Python中使用类的骰子生成器

Question

更新有人可能会因为我这样发帖而责怪我，但评论中没有足够的篇幅来涵盖这一点，他们特别告诉你不要用后续行动来回答自己的问题，所以这里。。。

我创建了骰子类，就像你们说的。

class dice():
    def __init__(self, sides, number):
        self.sides = sides
        self.number = number

    def roll(self):
        return random.randint(1, self.sides)

但是number参数没有做任何事情。

def att():
    d = dice(20, 2)
    base = d.roll()
    if base == 1:
        print 'Miss!'
    elif base == 20:
        crit = d.roll()
        if crit < 10:
            print 'Hit!'
        else:
            print 'Critical hit!\n'
            effect = super_crit()               
    else:
        print base

唯一能让我不止一次死去的方法就是这样做：

def initiative():
    d = dice(10, 1)
    ini = d.roll(), d.roll()
    print ini

我也试过：

def initiative():
    d = dice(10, 2)
    d.sides = 10
    d.number = 2
    ini = d.roll()
    print ini

在我看来这是多余的，但是我得到了一个Type Error:因为没有dice(10, 2)的参数太少。不管我用哪种方法，我都会得到同样的结果——一次死亡。我遗漏了什么吗？

原始帖子

我正在学习如何在Python2.7中使用类，作为练习，我正在为基于文本的RPG编写一个战斗模块。它使用老派掷骰子的方法来确定结果和效果。掷骰子决定胜负。如果一个自然的20是滚动，另一个滚动确定它是否是一个关键命中。如果critical hit=TRUE，则会滚动另一个模具以确定影响哪个身体部位。每一个身体部位都与字典中的数字1-12配对。根据受影响的部分，有三种可能的输出消息。我的问题是，返回的是整个值列表，而不是特定的部分。我在这里做错什么了？

是的，我知道这是超级书呆子。是的，我知道输出很差，但都是占位符。

import sys, random

#dice generator
class dice():
    def d4(self):
        number = random.randint(1, 4)
        return number

    def d6(self):
        number = random.randint(1, 6)
        return number

    def d10(self):
        number = random.randint(0, 9)
        return number

    def d12(self):
        number = random.randint(1, 12)
        return number

    def d20(self):
        number = random.randint(1, 20)
        return number

    def d100(self):
        number = random.randint(0, 99)
        return number 

#critical hit effect generator        
class super_crit(dice):
    def __init__(self):
        roll = dice()
        loc = roll.d12()
        hit_loc = {1 : 'Head',
                   2 : 'Left Arm',
                   3 : 'Right Arm',
                   4 : 'Left Leg',
                   5 : 'Right Leg',
                   6 : 'Left Hand',
                   7 : 'Right Hand',
                   8 : 'Left Foot',
                   9 : 'Right Foot',
                   10 : 'Chest',
                   11 : 'Stomach',
                   12 : 'Body'}
        part = hit_loc.values()
        for w in part:
            if loc <= 9:
                print w, "has been severed!"
            elif loc == 10:
                print "You sink your blade into his", w, "and pierce the heart!"
            elif loc == 11:
                print "You slash him across the", w, "and eviscerate him!"
            elif loc == 12:
                print "You shred the enemy's", w, "to ribbons!"

class attackRoll(dice):
        pass

#Attack function        
def att():
    roll = attackRoll()
    base = roll.d20()
    if base == 1:
        print 'Miss!'
    elif base == 20:
        crit = roll.d20()
        if crit < 10:
            print 'Hit!'
        else:
            effect = super_crit()               
    else:
        print base

def main():
    att()


if __name__ == '__main__':

main()

Answer 1

在dict的所有值上循环：

part = hit_loc.values()
for w in part:
    # loop over each part, so print a damage message for all 12 bodyparts

也许你是想选一个受影响的？

part = hit_loc[loc]  # assign *one* body part to `part`
if loc <= 9:
    print part, "has been severed!"
elif loc == 10:
    print "You sink your blade into his", part, "and pierce the heart!"
elif loc == 11:
    print "You slash him across the", part, "and eviscerate him!"
elif loc == 12:
    print "You shred the enemy's", part, "to ribbons!"

换句话说，这里根本不需要循环。

请注意，每当您发现自己使用一个连续的数字序列作为字典的键时，您也可以将其列为一个列表：

hit_loc = [
    'Head', 'Left Arm', 'Right Arm', 'Left Leg', 
    'Right Leg', 'Left Hand', 'Right Hand', 'Left Foot', 'Right Foot',
    'Chest', 'Stomach', 'Body'
]

除了现在索引从0运行到11，所以使用loc - 1查找正确的正文部分：

part = hit_loc[loc - 1]

Answer 2

切线。。。

骰子类的简单版本可能如下：

class Die(object):
    def __init__(self, sides = 6):
        self.sides = sides

    def roll(self):
        return randint(1, self.sides)

现在你有了一个通用的骰子对象，不需要每次你提出一个新的掷骰模式时都添加一个新的方法。E、 g

d = Die(10);
d.roll() # ---> some value between 1 and 10

添加可选的start和increment属性，这样您就可以有一个生成5, 10, ..., 95, 100的D20作为练习留给学生。

Answer 3

这看起来是一个学习Python的有趣程序。其他的答案大多涵盖了你所需要的，但我只想指出一件事：

如果你想在现实生活中用骰子来选择某样东西，方法是给这些东西分配数字，然后掷骰子，然后用骰子上的数字来判断选择了哪个东西。但是，在Python中，您可以做的事情比这简单得多：您可以告诉Python“这里有一堆东西，我希望随机选择一个项目”

所以对于重击，你可以替换这个：

hit_loc = {1 : 'Head',
           2 : 'Left Arm',
           3 : 'Right Arm',
           4 : 'Left Leg',
           5 : 'Right Leg',
           6 : 'Left Hand',
           7 : 'Right Hand',
           8 : 'Left Foot',
           9 : 'Right Foot',
          10 : 'Chest',
          11 : 'Stomach',
          12 : 'Body'}

# two steps to randomly choose a hit location
loc = roll.d12()
part = hit_loc[loc]

有了这个：

locations = ('Head', 'Left Arm', 'Right Arm', 'Left Leg', 'Right Leg',
         'Left Hand', 'Right Hand', 'Left Foot', 'Right Foot',
         'Chest', 'Stomach', 'Body')

# one step to randomly choose a hit location
part = random.choice(locations)

一般来说，当您想知道如何使用像random这样的模块时，阅读文档是值得的。在Python中，代码总是提供一些简洁的文档；从Python提示符可以执行以下操作：

>> import random
>> help(random)

help()命令将打印出简洁的文档，如果您通读它，您将发现random.choice()、random.shuffle()和其他漂亮的东西。

和Python玩得开心！

这是一个有趣的示例程序。不过，这并不是课堂上最好的例子。您在这里使用一个类只是为了获得一个将相关函数分组在一起的名称空间，这并不是错误的，但是当一个类封装一些数据和一些组合在一起的函数时，它更有用。这里有一个建议：创建一个名为hit_points的成员变量的Person()类，并编写一个攻击另一个Person实例的方法函数.attack()。然后编写一个程序，生成两个Person()实例，并让它们互相攻击！

我建议这样做：

black_knight = Person()
king_arthur = Person()

while True:
    king_arthur.attack(black_knight)
    if black_knight.hit_points <= 0:
        print "Victory is mine!"
        break
    black_knight.attack(king_arthur)
    if king_arthur.hit_points <= 0:
        print "None shall pass!"
        break

在本例中，一个Person实例将一个人的信息（生命点）和与一个人一起工作的函数（一个人可以attack另一个人）捆绑在一起。

你可以将模型扩展到包含关键命中；一个Person实例可以跟踪它收到的关键命中；一个Person实例可以有库存，包括总是获得关键命中的武器（例如“沃帕尔兔牙”、“圣手榴弹”等等）

事实上，你可以继续添加更多的东西来跟踪一个Person和更多的方法函数，如果你继续这样做，你可能会把整个事情变成一个真正的游戏。