Roguelike大全，part6

狂暴起来！

是时候把半兽人的头盔打扁了！

战斗几乎是任何游戏的重要部分，它把一款真正的游戏和一个教学demo区分开来

探索地下城很有趣，而一个简单的战斗系统将会更有趣，你会发现你玩游戏花的时间比开发游戏话的时间长很多

我们现在要开始做一个宏大的设计。至今为止，Object类对于应付玩家和敌人都是足够的。但是当我们深入下去，就会发现Object类有点不够用了，我们怎么解决这个问题呢？

我们可以假装没看到这个问题，而使用data-driven（数据驱动）的方案，就像很多老roguelike游戏做的那样。在这种方案中，所有的物体都有同样多的参数，只不过参数的数值不同罢了。在这里物体和物体之间没有参数数量上的差别。例如，一个参数可以用来表示一个怪物能否石化敌人，另一个能不能偷取物品或金钱，而其他的属性表示有没有魔法能力。。。

就如你可以想象的那样，如果每当你要增加一个新的属性时就要把所有的物体都赋值一次是非常烦人的。要解决这件糟心事，必须要减少属性的数量，要让特定的物体只有特定的属性，所以数据驱动这种方案不适合我们。

另一种常用的方案是"inheritance"（继承）。你定义父类和子类。子类继承父类的属性，又可以定义自己的属性（例如物体和怪物继承object类，但是可以衍生出自己特定的属性）。这种方案尖山了每个类的属性，并让物体之间看起来被清晰的区分

但是，这种区分又不是完全清晰的，由于父类的属性被子类继承，与子类的属性在同一区间内；他们的属性会由于命名问题互相影响。而且这里还存在着继承太深的问题。当你的开发越来越深入，你的继承可能会变得特别的长（例如Object > Item > Equipment > Weapon > Melee weapon > Blunt weapon > Mace > Legendary Mace of Deep Hierarchies）每层都可能为子类增加了一点点小函数。

事实上由于僵化的继承制度，权杖将无法既是武器又是魔法物品。我们想要自由的混合类与类。因此我们将使用继承的小老弟。composition

（组合）。它可没有上面两种方案所提到的缺点。

这种方案使用起来非常简单：这里有一个Object类，和其它的组合类。一个组合类定义了一些方法。而当你需要某一种特定类时，将Object类和这些方法类组合起来，这样一个新的类就即拥有Object类的方法，又拥有了组合类的方法。它甚至不需要额外的代码，让我们看看它是如何工作的吧！

我们的第一个组合类是Fighter。任何一个物体只要与这个类进行组合，都可以进行战斗。它包含了生命点hp，最大生命值。防御力和攻击力。

class Fighter:    #combat-related properties and methods (monster, player, NPC).    def __init__(self, hp, defense, power):        self.max_hp = hp        self.hp = hp        self.defense = defense        self.power = power

它将会在后面被扩展攻击和收到伤害的方法。

下面的是基础怪物类，包含了基础的AI函数。你可以实现其他的AI组合（例如远程攻击）并将他们用在怪物身上。我们定义了take_turn方法；就如同组合类实现他们的方法，这个方法被定义在BasicMonster类里。在这里它只打印一些调试信息。

class BasicMonster:    #AI for a basic monster.    def take_turn(self):        print 'The ' + self.owner.name + ' growls!'

忽略参数self.owner，它将在其他地方被初始化。我们以后再实现它。我们现在来讨论如何将一个组件组合到一个object上。这很简单，生成一个Fighter实例，以及（或）一个BasicMonster，让他们成为一个实例化的Object的一个参数

    def __init__(self, x, y, char, name, color, blocks=False, fighter=None, ai=None):

请注意所有的组件都是可选的；当你不需要时，他们可以被定义为None。他们将被保存为object的一个成员，例如 self.fighter = fighter。与此同时，由于一个组件需要知道谁拥有它，所以它需要获得它的父类引用，并将其保存在owner中

        self.fighter = fighter        if self.fighter:  #let the fighter component know who owns it            self.fighter.owner = self         self.ai = ai        if self.ai:  #let the AI component know who owns it            self.ai.owner = self

这里看起来有点诡异，不过我们可以通过这个owner获得其拥有类的引用，并进而获得其拥有类拥有的其他类的函数。这允许我们做很多事情。其它的系统实现不了这样的灵活度。这部分就是组合方案最复杂的代码了，其它的部分就纯粹是游戏逻辑了。

现在是决定怪物和玩家的一些属性的时候了。首先，定义玩家。实现一个Fighter组件，填好属性，并将其实现为fighter参数，成为玩家object的一个成员变量，在主循环之前实现这些：

#create object representing the playerfighter_component = Fighter(hp=30, defense=2, power=5) player = Object(0, 0, '@', 'player', libtcod.white, blocks=True, fighter=fighter_component)

在这里，我们决定使用keyword arguments来说明这些传参分别是什么(Fighter(30, 2, 5) 你很难看出来三个参数分别是什么)。一般情况下，第一个参数可以不写出名字，因为你可以默认认为它是某个特定参数（名字，颜色，等等）平衡代码的长度和可读性是一门艺术。不过可读性永远是优先的，这让你的代码更容易维护。

现在，怪物已经在place_objects函数里被实例化了。巨魔明显比兽人强壮。怪物们拥有两个组件：Fighter和BasicMonster

                #create an orc                fighter_component = Fighter(hp=10, defense=0, power=3)                ai_component = BasicMonster()                  monster = Object(x, y, 'o', 'orc', libtcod.desaturated_green,                    blocks=True, fighter=fighter_component, ai=ai_component)            else:                #create a troll                fighter_component = Fighter(hp=16, defense=1, power=4)                ai_component = BasicMonster()                  monster = Object(x, y, 'T', 'troll', libtcod.darker_green,                    blocks=True, fighter=fighter_component, ai=ai_component)

Keyword arguments在这里又得到了应用，未来你的大部分objects都将以这种方式生成。

AI

人工智能

是时候让你的怪物动起来了。我们这里将要实现的其实不是真正的人工智能，而只会是一种比较粗糙的智能。规则如下：如果看到了玩家人物，追他。事实上，我们认为怪物只要处于玩家的FOV里，它就会看到玩家。（这真是够糙的。。。）

我们在Object类里实现了一个追逐方法（move_towards），如果你对这部分不感兴趣，可以干脆直接使用而不细度代码。简单来说，我们设置了一个从物体到玩家的矢量，然后将其归一化，使其长度为一个tile，之后我们对结果矢量进行取整，这样我们就有了怪物下一个行动的方向。（x,y为0，-1或1）然后我们让怪物朝着这个方向运动一格，当然了，如果你线性代数不好，完全可以跳过这一段。

    def move_towards(self, target_x, target_y):        #vector from this object to the target, and distance        dx = target_x - self.x        dy = target_y - self.y        distance = math.sqrt(dx ** 2 + dy ** 2)          #normalize it to length 1 (preserving direction), then round it and        #convert to integer so the movement is restricted to the map grid        dx = int(round(dx / distance))        dy = int(round(dy / distance))        self.move(dx, dy)

另一个Object方法返回了两个object之间的距离，要使用这个函数你必须要在使用square root 函数的文件顶部 import math

    def distance_to(self, other):        #return the distance to another object        dx = other.x - self.x        dy = other.y - self.y        return math.sqrt(dx ** 2 + dy ** 2)

就像之前提到的，当怪物进入玩家FOV，则其开始激活并追逐玩家，下面是BasicMonster实现这个功能全部的代码。

class BasicMonster:    #AI for a basic monster.    def take_turn(self):        #a basic monster takes its turn. If you can see it, it can see you        monster = self.owner        if libtcod.map_is_in_fov(fov_map, monster.x, monster.y):              #move towards player if far away            if monster.distance_to(player) >= 2:                monster.move_towards(player.x, player.y)              #close enough, attack! (if the player is still alive.)            elif player.fighter.hp > 0:                print 'The attack of the ' + monster.name + ' bounces off your shiny metal armor!'

也许实现的不够完美，但是能凑合着用。你有兴趣的话可以改进这个方法。这里我们就先这样吧，最后一件事是让每一个智能怪兽在主循环的每一轮里运行这个函数

    if game_state == 'playing' and player_action != 'didnt-take-turn':        for object in objects:            if object.ai:                object.ai.take_turn()

试一试吧，这些恼人的怪物将会追逐你并尝试着攻击你。全部代码如下

The whole code is available here.

用剑来战斗

一场中世纪式的战争到了该结束的时候了。我们将实现一个真正的攻击函数并造成真正的杀伤，将这些傻叉怪物打成肉酱吧。函数很简单，你可以轻易的用自己的伤害系统替换这个函数。不管你如何实现，Fighter类都需要拥有一个造成伤害的类

    def take_damage(self, damage):        #apply damage if possible        if damage > 0:            self.hp -= damage

下一章我们修改这个函数让它可以造成死亡。而现在这个函数只是造成杀伤，代码如下

    def attack(self, target):        #a simple formula for attack damage        damage = self.power - target.fighter.defense          if damage > 0:            #make the target take some damage            print self.owner.name.capitalize() + ' attacks ' + target.name + ' for ' + str(damage) + ' hit points.'            target.fighter.take_damage(damage)        else:            print self.owner.name.capitalize() + ' attacks ' + target.name + ' but it has no effect!'

这里调用了之前实现的函数来造成伤害。我们将“攻击”和“伤害”分开，因为并不是只有攻击才能造成伤害，你可能在后面想加入毒药，陷阱之类的其他杀伤方法。现在将他们用起来吧，用这个函数替代之前怪物和玩家的攻击打印代码

                monster.fighter.attack(player)

        player.fighter.attack(target)

现在怪物和玩家终于可以互相伤害了，但是现在他们还不会挂，现在我们要做的是借着个机会实现玩家血量的显示，这样你会看到在怪物的攻击下，血量会降低。这里你将在render_all函数后面实现一个简单的GUI

    #show the player's stats    libtcod.console_set_default_foreground(con, libtcod.white)    libtcod.console_print_ex(con, 1, SCREEN_HEIGHT - 2, libtcod.BKGND_NONE, libtcod.LEFT,        'HP: ' + str(player.fighter.hp) + '/' + str(player.fighter.max_hp))

死亡

众所周知，没人能够无限的失去生命值而不死。（看来作者没看过圣斗士星矢）我们现在来实现由于失去生命而死亡的函数。这在Fighter类里处理。由于不同的Object在死亡的时候行为不一样，Fighter类必须知道它必须在object死亡之后调用什么函数。例如怪物要在死亡后留下尸体，玩家的死亡则导致游戏的失败，关底Boss的死亡导致去下一层的楼梯出现，诸如此类。这个death_function作为一个形参在创建Fighter实例时被传入

    def __init__(self, hp, defense, power, death_function=None):        self.death_function = death_function

在take_damage函数里，当HP达到0时，death_function函数被调用

            #check for death. if there's a death function, call it            if self.hp <= 0:                function = self.death_function                if function is not None:                    function(self.owner)

现在我们要定义一些有趣的死亡函数！它将物体的类型改变成尸体（功能尚未实现，先用打印的方法暂时凑合一下，这是一种很不错的调试新功能的方法）。而玩家的死亡会改变游戏的状态，导致玩家再也无法移动和攻击。

def player_death(player):    #the game ended!    global game_state    print 'You died!'    game_state = 'dead'     #for added effect, transform the player into a corpse!    player.char = '%'    player.color = libtcod.dark_red  def monster_death(monster):    #transform it into a nasty corpse! it doesn't block, can't be    #attacked and doesn't move    print monster.name.capitalize() + ' is dead!'    monster.char = '%'    monster.color = libtcod.dark_red    monster.blocks = False    monster.fighter = None    monster.ai = None    monster.name = 'remains of ' + monster.name

请注意怪物的组件被关闭了，因此它再也不能运行AI函数，再也无法攻击了。想要实现这个功能，要在生成monsters' Fighter组件时，使death_function=monster_death。同样的，生成player's Fighter 组件时，要使death_function=player_death。我们将打磨这部分功能。但是如果你性急的话，现在先试试看已经实现的功能吧。你可能会碰到一些小故障。在player_move_or_attack函数中，我们只希望玩家攻击那些有Fighter组件的物体，因此要改变object.x == x ... 代码行为如下代码

        if object.fighter and object.x == x and object.y == y:

这里还有一些问题，当玩家走过一具尸体，有时候它会遮住玩家！这怎么能够被允许呢？所以我们需要先绘制其他的物体，最后绘制玩家。

    #draw all objects in the list, except the player. we want it to    #always appear over all other objects! so it's drawn later.    for object in objects:        if object != player:            object.draw()    player.draw()

同样的事情也可能发生在怪物身上。所以写一个函数，让尸体永远首先被绘制，让后绘制的物体遮住尸体：

    def send_to_back(self):        #make this object be drawn first, so all others appear above it if they're in the same tile.        global objects        objects.remove(self)        objects.insert(0, self)

并且在怪物死亡之后运行这个函数

    monster.send_to_back()

现在我们有了一个随机的地下城，FOV，探索，敌人，AI和一个正儿八经的战斗系统。你现在可以杀死这些怪物并从它们的尸体上面跨过去了！也许你会发现在回合制下，这个游戏运行的没问题，但是在即时制下，怪物们运动的太快了，去链接里找答案吧

check out this Extra on real-time combat.

完整代码如下

The whole code is available here.

--------------------------------------------------------------------------------

Going Berserk!

狂暴起来！

The components

Finally, it's time to bash some orc helmets into tiny metal pancakes! 

Combat is a big turning point in the development of any game: it separates the game from the tech demo. 

是时候把半兽人的头盔打扁了！

战斗几乎是任何游戏的重要部分，它把一款真正的游戏和一个教学demo区分开来

Although dungeon exploration is interesting, the simplest fight can be far more fun, and you may even find yourself playing your game more than you code it!

探索地下城很有趣，而一个简单的战斗系统将会更有趣，你会发现你玩游戏花的时间比开发游戏话的时间长很多

We have a big design decision ahead of us. Until now, the Object class was enough to hold the properties of both the player and the enemies. But as we develop further, many properties will make sense for one kind of Object, but not for another. How do we solve this?

我们现在要开始做一个宏大的设计。至今为止，Object类对于应付玩家和敌人都是足够的。但是当我们深入下去，就会发现Object类有点不够用了，我们怎么解决这个问题呢？

Well, we could just pretend that this is not a problem, and use the data-driven approach, which is used by many of the older roguelikes. In this approach, all objects have the same set of properties, and only the values of these properties are modified from object to object. There isn't any feature variation between different objects. For example, there might be a property that determines whether a monster has a petrification attack, another for stealing items or gold, other properties for magical capabilities...

我们可以假装没看到这个问题，而使用data-driven（数据驱动）的方案，就像很多老roguelike游戏做的那样。在这种方案中，所有的物体都有同样多的参数，只不过参数的数值不同罢了。在这里物体和物体之间没有参数数量上的差别。例如，一个参数可以用来表示一个怪物能否石化敌人，另一个能不能偷取物品或金钱，而其他的属性表示有没有魔法能力。。。

As can be seen, it becomes quite tedious to implement a new property for all items every time you want to add a new feature to only one. The only way around this is to limit the number of properties, which in turn limits the number of special features that can be added. This is, of course, not good for us.

就如你可以想象的那样，如果每当你要增加一个新的属性时就要把所有的物体都赋值一次是非常烦人的。要解决这件糟心事，必须要减少属性的数量，要让特定的物体只有特定的属性，所以数据驱动这种方案不适合我们。

The other popular alternative is inheritance. You define a hierarchy of parent (a.k.a. base) and child (a.k.a. derived) classes. Child/derived classes (like Item or Monster), in addition to their own properties, receive the properties from their parent classes (such as Object). This reduces redundancy, and there's a seemingly clean separation between different classes.

另一种常用的方案是"inheritance"（继承）。你定义父类和子类。子类继承父类的属性，又可以定义自己的属性（例如物体和怪物继承object类，但是可以衍生出自己特定的属性）。这种方案尖山了每个类的属性，并让物体之间看起来被清晰的区分

However, the separation is not exactly clean, since the properties of parent classes are 'pasted' on the same space as the child's properties; their properties can conflict if they share names. And there's also the temptation to define deep hierarchies of classes. As you develop further, your hierarchy will grow to extreme lengths (such as Object > Item > Equipment > Weapon > Melee weapon > Blunt weapon > Mace > Legendary Mace of Deep Hierarchies). Each level can add just a tiny bit of functionality over the last one.

但是，这种区分又不是完全清晰的，由于父类的属性被子类继承，与子类的属性在同一区间内；他们的属性会由于命名问题互相影响。而且这里还存在着继承太深的问题。当你的开发越来越深入，你的继承可能会变得特别的长（例如Object > Item > Equipment > Weapon > Melee weapon > Blunt weapon > Mace > Legendary Mace of Deep Hierarchies）每层都可能为子类增加了一点点小函数。

The fact that a Mace can't be both a Weapon and a Magic Item due to the rigid hierarchy is a bummer. Shuffling classes and code around to achieve these simple tasks is common with inheritance. We want to be able to mix and match freely! Hence, we have inheritance's older, but often forgotten, cousin: composition. It has none of the disadvantages listed above.

事实上由于僵化的继承制度，权杖将无法既是武器又是魔法物品。我们想要自由的混合类与类。因此我们将使用继承的小老弟。composition

（组合）。它可没有上面两种方案所提到的缺点。

It's dead simple: there's the Object class, and some component classes. A component class defines extra properties and methods for an Object that needs them. Then you just slap an instance of the component class as a property of the Object; it now "owns" the component. It doesn't even require special functions or code! Let's see how it works.

这种方案使用起来非常简单：这里有一个Object类，和其它的组合类。一个组合类定义了一些方法。而当你需要某一种特定类时，将Object类和这些方法类组合起来，这样一个新的类就即拥有Object类的方法，又拥有了组合类的方法。它甚至不需要额外的代码，让我们看看它是如何工作的吧！

Our first component will be the Fighter. Any object that can fight or be attacked must have it. It holds hit points, maximum hit points (for healing), defense and attack power.

我们的第一个组合类是Fighter。任何一个物体只要与这个类进行组合，都可以进行战斗。它包含了生命点hp，最大生命值。防御力和攻击力。

class Fighter:    #combat-related properties and methods (monster, player, NPC).    def __init__(self, hp, defense, power):        self.max_hp = hp        self.hp = hp        self.defense = defense        self.power = power

It'll later be augmented with methods to attack and take damage.

Then there's the BasicMonster component, which holds basic AI routines. You can create other AI components (say, for ranged combat) and use them for some monsters. We'll define a take_turn method; as long as a component defines this method, it's a valid alternative to BasicMonster. For now it just prints a debug message:

它将会在后面被扩展攻击和收到伤害的方法。

下面的是基础怪物类，包含了基础的AI函数。你可以实现其他的AI组合（例如远程攻击）并将他们用在怪物身上。我们定义了take_turn方法；就如同组合类实现他们的方法，这个方法被定义在BasicMonster类里。在这里它只打印一些调试信息。

class BasicMonster:    #AI for a basic monster.    def take_turn(self):        print 'The ' + self.owner.name + ' growls!'

Ignore the reference to self.owner -- it's just the Object instance that owns this component, and is initialized elsewhere. We'll get to that in a moment. So how do we associate components with an Object? It's simple: create a Fighter instance, and/or a BasicMonster instance, and pass them as parameters when initializing the Object:

忽略参数self.owner，它将在其他地方被初始化。我们以后再实现它。我们现在来讨论如何将一个组件组合到一个object上。这很简单，生成一个Fighter实例，以及（或）一个BasicMonster，让他们成为一个实例化的Object的一个参数

    def __init__(self, x, y, char, name, color, blocks=False, fighter=None, ai=None):

Notice that all components are optional; they can be None if you don't want them. Then they're stored as properties of the object, for example with self.fighter = fighter. Also, since a component will often want to deal with its owner Object, it has to "know" who it is (for example, to get its position, or its name -- as you noticed earlier, BasicMonster 's take_turn method needs to know the object's name to display a proper message). So, in addition to holding the component, the Object will set the component's owner property to itself. The if lines just make sure this happens only if the component is actually defined.

请注意所有的组件都是可选的；当你不需要时，他们可以被定义为None。他们将被保存为object的一个成员，例如 self.fighter = fighter。与此同时，由于一个组件需要知道谁拥有它，所以它需要获得它的父类引用，并将其保存在owner中

        self.fighter = fighter        if self.fighter:  #let the fighter component know who owns it            self.fighter.owner = self         self.ai = ai        if self.ai:  #let the AI component know who owns it            self.ai.owner = self

This may look a bit weird, but now we can follow these properties around to go from a component (self), to its owner object (self.owner), to a different one of its components (self.owner.ai), allowing us to do all sorts of funky stuff! Most other systems don't have this kind of flexibility for free. This is actually the most complicated code that composition needs; the rest will be pure game logic!

OK, now it's time to decide on some stats for the monsters and the player! First up, the player. Just create a Fighter component with the stats you choose, and set it as the fighter parameter when creating the player object. Place it above the main loop:

这里看起来有点诡异，不过我们可以通过这个owner获得其拥有类的引用，并进而获得其拥有类拥有的其他类的函数。这允许我们做很多事情。其它的系统实现不了这样的灵活度。这部分就是组合方案最复杂的代码了，其它的部分就纯粹是游戏逻辑了。

现在是决定怪物和玩家的一些属性的时候了。首先，定义玩家。实现一个Fighter组件，填好属性，并将其实现为fighter参数，成为玩家object的一个成员变量，在主循环之前实现这些：

#create object representing the playerfighter_component = Fighter(hp=30, defense=2, power=5) player = Object(0, 0, '@', 'player', libtcod.white, blocks=True, fighter=fighter_component)

Here, I decided to use keyword arguments to make it clear what the different stats are (Fighter(30, 2, 5) is hard to interpret). They're not necessary for the first few arguments of Object since you can easily deduce what they mean (name, color, etc). This is common sense for most people, but I'll say it anyway: always try to strike a good balance between short and readable code; in places where you can't, pepper it with lots explanatory comments. It will make your code much easier to maintain!

Now, the monsters are defined in place_objects. Trolls will be obviously stronger than orcs. Monsters have two components: Fighter and BasicMonster.

在这里，我们决定使用keyword arguments来说明这些传参分别是什么(Fighter(30, 2, 5) 你很难看出来三个参数分别是什么)。一般情况下，第一个参数可以不写出名字，因为你可以默认认为它是某个特定参数（名字，颜色，等等）平衡代码的长度和可读性是一门艺术。不过可读性永远是优先的，这让你的代码更容易维护。

现在，怪物已经在place_objects函数里被实例化了。巨魔明显比兽人强壮。怪物们拥有两个组件：Fighter和BasicMonster

                #create an orc                fighter_component = Fighter(hp=10, defense=0, power=3)                ai_component = BasicMonster()                  monster = Object(x, y, 'o', 'orc', libtcod.desaturated_green,                    blocks=True, fighter=fighter_component, ai=ai_component)            else:                #create a troll                fighter_component = Fighter(hp=16, defense=1, power=4)                ai_component = BasicMonster()                  monster = Object(x, y, 'T', 'troll', libtcod.darker_green,                    blocks=True, fighter=fighter_component, ai=ai_component)

Keyword arguments come to the rescue again, since in the future most objects will have only a handful of all possible components. This way you can set only the ones you want, even if they're out-of-order!

Keyword arguments在这里又得到了应用，未来你的大部分objects都将以这种方式生成。

AI

It's time to make our monsters move and kick about! It's not really "artificial intelligence", as these guys will be pretty thick. The rule for them is: if you see the player, chase him. Actually, we'll assume that the monster can see the player if its within the player's FOV.

We'll create a chasing method (move_towards) in the Object class, which can be used to simplify all your AI functions. It has a bit of vector mathematics, but if you're not into that you can use it without understanding how it works. Basically, we get a vector from the object to the target, then we normalize it so it has the same direction but has a length of exactly 1 tile, and then we round it so the resulting vector is integer (instead of fractional as usual - so dx and dy can only take the values 0, -1 or +1). The object then moves by this amount. Of course, you don't have to understand the math thoroughly in order to use it!

人工智能

是时候让你的怪物动起来了。我们这里将要实现的其实不是真正的人工智能，而只会是一种比较粗糙的智能。规则如下：如果看到了玩家人物，追他。事实上，我们认为怪物只要处于玩家的FOV里，它就会看到玩家。（这真是够糙的。。。）

我们在Object类里实现了一个追逐方法（move_towards），如果你对这部分不感兴趣，可以干脆直接使用而不细度代码。简单来说，我们设置了一个从物体到玩家的矢量，然后将其归一化，使其长度为一个tile，之后我们对结果矢量进行取整，这样我们就有了怪物下一个行动的方向。（x,y为0，-1或1）然后我们让怪物朝着这个方向运动一格，当然了，如果你线性代数不好，完全可以跳过这一段。

    def move_towards(self, target_x, target_y):        #vector from this object to the target, and distance        dx = target_x - self.x        dy = target_y - self.y        distance = math.sqrt(dx ** 2 + dy ** 2)          #normalize it to length 1 (preserving direction), then round it and        #convert to integer so the movement is restricted to the map grid        dx = int(round(dx / distance))        dy = int(round(dy / distance))        self.move(dx, dy)

Another useful Object method returns the distance between two objects, using the common distance formula. You need import math at the top of the file in order to use the square root function.

另一个Object方法返回了两个object之间的距离，要使用这个函数你必须要在使用square root 函数的文件顶部 import math

    def distance_to(self, other):        #return the distance to another object        dx = other.x - self.x        dy = other.y - self.y        return math.sqrt(dx ** 2 + dy ** 2)

As mentioned earlier, the behavior is simply "if you see the player, chase him". Here's the full code for the BasicMonster class that does it. The monster is only active if its within the player's FOV.

就像之前提到的，当怪物进入玩家FOV，则其开始激活并追逐玩家，下面是BasicMonster实现这个功能全部的代码。

class BasicMonster:    #AI for a basic monster.    def take_turn(self):        #a basic monster takes its turn. If you can see it, it can see you        monster = self.owner        if libtcod.map_is_in_fov(fov_map, monster.x, monster.y):              #move towards player if far away            if monster.distance_to(player) >= 2:                monster.move_towards(player.x, player.y)              #close enough, attack! (if the player is still alive.)            elif player.fighter.hp > 0:                print 'The attack of the ' + monster.name + ' bounces off your shiny metal armor!'

That's not terribly smart, but it gets the job done! You can, of course, improve it a lot; for now we'll just leave it like this and continue working on combat. The last thing is to call take_turn for any intelligent monsters from the main loop:

也许实现的不够完美，但是能凑合着用。你有兴趣的话可以改进这个方法。这里我们就先这样吧，最后一件事是让每一个智能怪兽在主循环的每一轮里运行这个函数

    if game_state == 'playing' and player_action != 'didnt-take-turn':        for object in objects:            if object.ai:                object.ai.take_turn()

Ready to test! The annoying little buggers will now chase you and try to hit you.

The whole code is available here.

试一试吧，这些恼人的怪物将会追逐你并尝试着攻击你。全部代码如下

The whole code is available here.

Sword-fighting

The quest for some epic medieval combat is coming to an end! We will now write the actual functions to attack and take damage, and replace those silly placeholders with the meaty stuff.

The "meaty stuff" is deliberately simple. This is so you can easily change it with your own damage system, whatever it may be. The Fighter class will have a method to take damage:

用剑来战斗

一场中世纪式的战争到了该结束的时候了。我们将实现一个真正的攻击函数并造成真正的杀伤，将这些傻叉怪物打成肉酱吧。函数很简单，你可以轻易的用自己的伤害系统替换这个函数。不管你如何实现，Fighter类都需要拥有一个造成伤害的类

    def take_damage(self, damage):        #apply damage if possible        if damage > 0:            self.hp -= damage

In the next section we'll modify it to also handle deaths. Then there's the method to attack another object:

下一章我们修改这个函数让它可以造成死亡。而现在这个函数只是造成杀伤，代码如下

    def attack(self, target):        #a simple formula for attack damage        damage = self.power - target.fighter.defense          if damage > 0:            #make the target take some damage            print self.owner.name.capitalize() + ' attacks ' + target.name + ' for ' + str(damage) + ' hit points.'            target.fighter.take_damage(damage)        else:            print self.owner.name.capitalize() + ' attacks ' + target.name + ' but it has no effect!'

It calls the previous method in order to handle taking damage. We separated "attacks" and "damage" because you might want an event, like poison or a trap, to directly damage an object by some amount, without going through the attack damage formula.

Now to give them some use. In the BasicMonster 's take_turn method, replace the dummy print line for the monster's attack with:

这里调用了之前实现的函数来造成伤害。我们将“攻击”和“伤害”分开，因为并不是只有攻击才能造成伤害，你可能在后面想加入毒药，陷阱之类的其他杀伤方法。现在将他们用起来吧，用这个函数替代之前怪物和玩家的攻击打印代码

                monster.fighter.attack(player)

And the dummy print line for the player's attack, in player_move_or_attack, with:

        player.fighter.attack(target)

That's it, the player and the monsters can beat each other silly, but no-one will die. We'll take this opportunity to print the player's HP so you can see it plummeting to negative values as the monsters attack you. This is how you make a simple GUI! At the end of the render_all function:

现在怪物和玩家终于可以互相伤害了，但是现在他们还不会挂，现在我们要做的是借着个机会实现玩家血量的显示，这样你会看到在怪物的攻击下，血量会降低。这里你将在render_all函数后面实现一个简单的GUI

    #show the player's stats    libtcod.console_set_default_foreground(con, libtcod.white)    libtcod.console_print_ex(con, 1, SCREEN_HEIGHT - 2, libtcod.BKGND_NONE, libtcod.LEFT,        'HP: ' + str(player.fighter.hp) + '/' + str(player.fighter.max_hp))

Untimely deaths

不合时宜的死亡

Of course, nobody can lose HP indefinitely. We'll now code the inevitable demise of both the monsters and the player! This is handled by the Fighter class. Since different objects have different behaviors when killed, the Fighter class must know what function to call when the object dies. This is so that monsters leave corpses behind, the player loses the game, the end-level boss reveals the stairs to the next level, etc. This death_function is passed as a parameter when creating a Fighter instance.

众所周知，没人能够无限的失去生命值而不死。（看来作者没看过圣斗士星矢）我们现在来实现由于失去生命而死亡的函数。这在Fighter类里处理。由于不同的Object在死亡的时候行为不一样，Fighter类必须知道它必须在object死亡之后调用什么函数。例如怪物要在死亡后留下尸体，玩家的死亡则导致游戏的失败，关底Boss的死亡导致去下一层的楼梯出现，诸如此类。这个death_function作为一个形参在创建Fighter实例时被传入

    def __init__(self, hp, defense, power, death_function=None):        self.death_function = death_function

It is then called by the take_damage method, in the event that the HP reaches 0:

在take_damage函数里，当HP达到0时，death_function函数被调用

            #check for death. if there's a death function, call it            if self.hp <= 0:                function = self.death_function                if function is not None:                    function(self.owner)

Now we'll define some fun death functions! They just change the object so it looks like a corpse, as well as printing some messages. The player's death also changes the game state, so he can't move or attack any more.

现在我们要定义一些有趣的死亡函数！它将物体的类型改变成尸体（功能尚未实现，先用打印的方法暂时凑合一下，这是一种很不错的调试新功能的方法）。而玩家的死亡会改变游戏的状态，导致玩家再也无法移动和攻击。

def player_death(player):    #the game ended!    global game_state    print 'You died!'    game_state = 'dead'     #for added effect, transform the player into a corpse!    player.char = '%'    player.color = libtcod.dark_red  def monster_death(monster):    #transform it into a nasty corpse! it doesn't block, can't be    #attacked and doesn't move    print monster.name.capitalize() + ' is dead!'    monster.char = '%'    monster.color = libtcod.dark_red    monster.blocks = False    monster.fighter = None    monster.ai = None    monster.name = 'remains of ' + monster.name

Notice that the monster's components were disabled, so it doesn't run any AI functions and can no longer be attacked.

To assign these behaviours to the player and monsters, pass the extra parameter death_function=monster_death when creating the monsters' Fighter component, in place_objects; and also when creating the player's Fighter component before the main loop (death_function=player_death).

We'll add a few details to polish it up. For the impatient, however: it's ready to play now! You may notice some glitches though. In player_move_or_attack, we only want the player to attack objects that have a Fighter component. So change the if object.x == x ... line to:

请注意怪物的组件被关闭了，因此它再也不能运行AI函数，再也无法攻击了。想要实现这个功能，要在生成monsters' Fighter组件时，使death_function=monster_death。同样的，生成player's Fighter 组件时，要使death_function=player_death。我们将打磨这部分功能。但是如果你性急的话，现在先试试看已经实现的功能吧。你可能会碰到一些小故障。在player_move_or_attack函数中，我们只希望玩家攻击那些有Fighter组件的物体，因此要改变object.x == x ... 代码行为如下代码

        if object.fighter and object.x == x and object.y == y:

There's also currently the issue that, when the player walks over a corpse, sometimes it's drawn over the player! There's no guarantee that the player is the object that is drawn last. So we need to draw all other objects first, and only then the player. Just change the rendering loop in render_all to:

这里还有一些问题，当玩家走过一具尸体，有时候它会遮住玩家！这怎么能够被允许呢？所以我们需要先绘制其他的物体，最后绘制玩家。

    #draw all objects in the list, except the player. we want it to    #always appear over all other objects! so it's drawn later.    for object in objects:        if object != player:            object.draw()    player.draw()

The same thing also happens with monsters -- a monster corpse being drawn over another monster. To fix it, create a method in the Object class that moves it to the start of the list, so it's drawn first:

同样的事情也可能发生在怪物身上。所以写一个函数，让尸体永远首先被绘制，让后绘制的物体遮住尸体：

    def send_to_back(self):        #make this object be drawn first, so all others appear above it if they're in the same tile.        global objects        objects.remove(self)        objects.insert(0, self)

And call it somewhere in the monster_death function:

并且在怪物死亡之后运行这个函数

    monster.send_to_back()

It's finally ready to play, and it actually feels like a game! It was a long journey since we first printed the @ character, but we've got random dungeons, FOV, exploration, enemies, AI, and a true combat system. You can now beat those pesky monsters into a pulp and walk over them! (Ugh!) See if you can finish off all of them before they do the same to you.

You may have noticed that this is fine and dandy for a turn-based game, but in a real-time game the monsters are just too fast! If that happens to be the case with your game, check out this Extra on real-time combat.

现在我们有了一个随机的地下城，FOV，探索，敌人，AI和一个正儿八经的战斗系统。你现在可以杀死这些怪物并从它们的尸体上面跨过去了！也许你会发现在回合制下，这个游戏运行的没问题，但是在即时制下，怪物们运动的太快了，去链接里找答案吧

The whole code is available here.