练习43--面向对象的分析和设计基础

一 设计方法和技巧

1 设计过程

• 1. 把问题写或者划下来。
• 2. 提炼出关键概念，并进行研究。
• 3. 为这些概念创建一个类的层级和对象关系图。
• 4. 写下这些类的代码，并测试运行。
• 5. 重复和改进。

这是一种“自上而下”的方式，它从非常抽象、松散的想法开始，然后慢慢提炼，直到想法变得具体，可以通过代码来实现

2 详细设计技巧

       我会先从写下问题开始，尽可能地写下我所能想到的点。可能我还会画一两张图表、地图之类的，甚至会给我自己写一系列邮件来阐述这个问题。这样能让我针对这个问题把一些关键的概念表达出来，并且探索出关于该问题我可能已经掌握的东西。

       然后我会过一遍这些笔记、图表以及描述，从其中抽象出关键概念。这里有一个小技巧：把你所写所画的东西里面所有的名词和动词列一个表出来，然后写下它们之间是如何相互关联的。这种方法让我得到了一个关于下一步的类、对象和函数名的列表。我拿着这个概念列表，研究其中我不明白的点，如果我需要的话，对其进行改进。

       一旦我有了这个概念列表，我就创造了一个简单的概念框架，以及它们作为类是如何相互关联的。你可以经常列你的名词表，然后问自己“这个跟其他的概念名词类似吗？也就是说，它们有共同的父类吗？有的话应该叫什么？”重复这个过程直到你得到一个类的层级结构，可能就是一个简单的树状图或者示意图。然后把所有的动词挑出来，看看它们能不能作为每个类的函数名，然后把它们放到你的树状图里面。

       等类的层级结构梳理清楚之后，我会坐下来，写一些基本的代码框架，只是一些类和它们的函数，没有其他东西。然后我会写一些测试代码，跑一下，看这些类有没有意义以及能不能正常运行。有时我会先写测试代码，有时候就是一小段测试，一小段代码，再一小段测试，以此类推，直到我把整个程序构建起来。

       最后，我会重复这个过程，并且在运行的过程中不断精简，在添加更多应用之前让代码更简洁明了。如果我在某个特定环节因为一个概念或者我没有预料到的问题而卡壳，我会坐下来，只运行这一部分，直到把问题弄明白之后再继续。

二 一个简单的游戏引擎分析——“来自25号行星的哥顿人”（Gothons from Planet Percal #25）

1 写或画出这个问题

（1）我会写一小段关于这个游戏的文字——游戏是干什么的，类似于需求分析吧，或者最后的实现效果：

“外星人入侵了一艘宇宙飞船，我们的英雄必须穿过迷宫般的房间打败他们，这样他才能逃到逃生舱去到下面的星球。游戏更像是 Zork 之类的文字冒险游戏，并且有着很有意思的死亡方式。这款游戏的引擎会运行一张满是房间或场景的地图。当玩家进入游戏时，每个房间都会打印自己的描述，然后告诉引擎下一步该运行地图中的哪个房间。”

（2）这时我有了一个关于这个游戏以及它如何运行的好想法，所以现在我要描述一下每个场景：——将需求分解，逐步完成

• 死亡（Death）：玩家死的时候，会非常有意思。
• 中央走廊（Central Corridor）：这是起点，已经有一个哥顿人站在那里，在继续之前，玩家必须用一个笑话来击败他。
• 房间（Room）：不同的房间存在不同的陷阱，成功避过这些陷阱的话就会更加接近目的地。
• 激光武器军械械库（Laser Weapon Armory）：这是英雄在到达逃生舱之前用中子弹炸毁飞船的地方。这里有一个键盘，英雄必须猜出数字。
• 桥（The Bridge）：另一个和哥顿人战斗的场景，英雄在这里放置了炸弹。
• 逃生舱（Escape Pod）：英雄逃脱的地方，前提是他猜出正确的逃生舱。

 

2 抽取关键概念并予以研究

我现在有足够的信息来提取其中的名词，并分析他们的类层级结构。首先，我会做一个所有名词的列表：

• Alien（外星人）

• Player（玩家）

• Ship（飞船）

• Maze（迷宫）

• Room（房间）

• Scene（场景）

• Gothon（哥特人）

• Escape Pod（逃生舱）

• Planet（行星）

• Map（地图）

• Engine（引擎）

• Death（死亡）

• Central Corridor（中央走廊）

• Laser Weapon Armory（激光武器军械库）

• The Bridge（桥）

我可能还会浏览一遍所有的动词，看它们适不适合作为函数名，但是我会先暂时跳过这一步。

       现在你可能也会研究一下每个概念以及任何你不明白的东西。比如，我会玩几个同类型的游戏，确保我知道它们是如何工作的。我可能还会研究船是如何设计的或者炸弹是怎么用的。还有一些技术性问题，比如如何把游戏状态储存在数据库中。当我完成这些研究，我可能会基于这些新信息从第一步开始，重新写我的描述，并做概念提取。

3 为这些概念创建类的层级结构和对象地图

        很快我就发现“房间”（“Room”）和“场景”（“Scene”）基本上是同一种东西，取决于我想用它们来做什么。在这个游戏中我选择用“场景”。然后我意识到所有特定的房间比如“中央走廊”其实就是“场景”。我还发现“死亡”（“Death”）也可以说是场景，这确认了我选择“场景”而不是“房间”的正确性，因为你可以说“死亡”是一种场景，但如果说它是一个“房间”就有点奇怪了。“迷宫”（“Maze”）和“地图”（“Map”）也基本上是同一种东西，我会选择用“地图”，因为我更常用它。我不想做一个战斗系统，所以我会暂时忽略“外星人”（“Alien”）和“玩家”（“Player”）这两个东西，先保存起来以备后用。“行星”（“Planet”）也可以是另一种场景，而不是其他特定的东西。

经过上述思考过程，我开始创建一个看起来像这样的类的层级结构：

然后我会浏览一遍，基于我描述里面的东西，想想看每个类下面需要些什么动作。例如，我从描述里知道，我需要一种方式来“运行”这个引擎，从地图“到达下一个场景”，到达“开场”，并“进入”一个场景，我会像这样把这些动作加上：

注意我只把“enter”放在了“场景”下面，所有“场景”下面的东西都会继承这个动作，需要随后再重写。

4 编写类代码并通过测试来运行

一旦我有了这个类和函数的树状图，我在我的编辑器里面打开一个源文件，试着写它们的代码。通常我就是把树状图里的东西复制粘贴到源文件里，然后把它们编辑成类。下面是它们最开始的样子，文件最后放了一个小测试：

ex43_classes.py

class Scene(object):

    def enter(self):
    pass

class Engine(object):
    
    def __init__(self, scene_map):
    pass

    def play(self):
    pass

class Death(Scene):

    def enter(self):
    pass
    
class CentralCorridor(Scene):

    def enter(self):
    pass
    
class LaserWeaponArmory(Scene):
    
    def enter(self):
    pass

class TheBridge(Scene):

    def enter(self):
    pass
    
class EscapePod(Scene):

    def enter(self):
    pass

class Map(object):

    def __init__(self, start_scene):
    pass

    def next_scene(self, scene_name):
    pass

    def opening_scene(self):
    pass


a_map = Map('central_corridor')
a_game = Engine(a_map)
a_game.play()

在这个文件中你可以看到，我只是复制了层级结构中我想要的东西，并在最后加上了一些测试代码来运行，看这个基本结构能不能成立。在这个练习后面的几部分，你会填上剩余的代码，让它像游戏描述中那样运行。 

5 重复和改进

       过程的最后一步准确来说不是一个步骤，而像是一个 while 循环。你不可能一次完成这个过程。相反，你会再次回顾整个过程，并根据你从后续步骤中学到的信息对其进行改进。有时我会进入第三步，然后意识到我需要再回到第一步和第二步，那我就会停下来，回到前面去做。有时我会灵光一闪，跳到最后，把脑子里的解决方案代码敲出来，然后再回过头来做前面的步骤，以确保我涵盖了所有可能的情况。

       在这个过程中你需要注意的另一个问题是，它不仅仅是你在一个单一层面上做的事，而是当你遇到一个特定的问题时，你可以在每个层面上做的事情。假设我不知道怎么写 Engine.play 这个方法。我可以停下来，把整个过程专注在这一个函数上来弄明白代码应该怎么写。

三 自上而下VS自下而上

这个过程通常被称为“自上而下”，因为它从最抽象的概念（上）开始，然后一直向下到实际的应用。我希望你能从现在开始分析这本书里遇到的问题时使用我刚才描述的这个过程，但是你应该知道编程中还有另一种解决问题的方式，那就是，从写代码开始，然后逐渐“上升”到抽象的概念，这种方式被称为“自下而上”。它的步骤大致如下： 

1. 从问题中拿出一小部分，开始写简单的能运行的代码。

2. 然后用类和自动化测试来把代码改进地更正式一些。

3. 抽象出你所使用的关键概念，试着探究一下它们。

4. 针对正在发生的事情写一段描述。

5. 回过头去继续改进代码，也可能把之前写的删掉重新开始。

6. 转到这个问题的其他部分，然后重复以上步骤。 

       这个过程只有在你对编程已经比较熟练并且面对问题能够自然使用编程思维的情况下才会更好，同时，当你知道整个工程的一小部分、却对全局概念的信息掌握不全的时候，这个方法也很好用。你可以将整个过程拆解成很多小块，然后边写代码边探索，这样可以帮助你一点一点地钻研这个问题，直到整个问题都得到解决。

四  “来自25号行星的哥顿人”游戏代码

1 代码讲解

导入部分：

from sys import exit
from random import randint
from textwrap import dedent

这是游戏所需库的基本引入。唯一的新东西是从 textwrap 模块导入 dedent 函数。这个函数将帮助我们使用 """ （三引号）字符串来编写我们的房间描述。它就是简单地从字符串的行首删除空白。如果没有这个函数，使用 """ 样式字符串就会失败，因为它们在屏幕上缩进的程度与Python代码相同。 

基类Scene创建部分：

class Scene(object):
    
    def enter(self):
        print("This scene is not yet configured.")
        print("Subclass it and implement enter().")
        exit(1)

正如你在框架代码中看到的，我有一个基类 Scene，它具有所有场景都具有的公共功能。在这个简单的程序中，它们不会做太多的工作，只是向你演示如何创建基类。 

Engine类创建部分：

class Engine(object):
    
    def __init__(self,scene_map):
        self.scene_map = scene_map
        
    def play(self):
        current_scene = self.scene_map.opening_scene()
        last_scene = self.scene_map.next_scene('finished')
        
        while current_scene != last_scene:
            next_scene_name = current_scene.enter()
            current_scene = self.scene_map.next_scene(next_scene_name)
        
        # be sure to print out the last scene
        current_scene.enter()

我还有 Engine 类。你可以看到我已经在使用 Map.opening_scene 和 Map.next_scene 这两个方法了。因为我已经提前计划好了，所以可以在写出 Map 类之前就把这些方法写下来并用起来。 

Death类创建部分：

class Death(Scene):
    
    quips = [
        "You died.You kinda suck at this.",
        "Your Mom would be proud...if she ware smarter.",
            "Such a     luser.",
            "I have     a small puppy that's better at this.",
            "You're     worse than your Dad's jokes."
    ]
    
    def enter(self):
        print(Death.quips[randint(0,len(self.quips)-1)])
        exit(1)

我的第一个场景很反常地设置为了 Death，主要是想向你展示你可以写的最简单的场景。

CentralCorridor中央走廊部分的创建：

class CentralCorridor(Scene):
    
    def enter(self):
        print(dedent("""
            The Gothons of Planet Percal #25 have invaded your ship and
            destroyed your entire crew.You are the last surviving
            member and your last mission is to get the neutron destruct
            bomb from the weapons Armory,put it in the bridge,and 
            blow the ship up after getting into an escape pod.
            
            You're running down the central corridor to the Weapons
            Armory when a Gothon jumps out,red scaly skin,dark grimy
            teeth,and evil clown costume flowing around his hate
            filled body.He's blocking the door to the Armory and
            about to pull a weapon to blast you.
        """))
        
        action = input("> ")
        
        if action == "shoot!":
            print(dedent("""
                Quick on the draw you yank out your blaster and fire
                it an the Gothon. His clown costume is flowing and
                moving around his body,which throws off your aim.
                Your laser hits his costume but misses him entirely.
                This completely ruins his brand new costume his mother
                bought him,which makes him fly into an insame rage
                and blast you repeatedly in the face until you are 
                dead.Then he eats you.
            """))
            return 'death'
        
        elif action == "dodge!":
            print(dedent("""
                Like a word class boxer you dodge,weave,slip and
                slide right as the Gothon's blaster cranks a laser
                past your head.In the middle of your artful dodge
                your foot slips and you bang your head on the metal
                wall and pass out.You wake up shortly after only to
                die as the Gothon stomps on your head and eats you.
            """))
            return 'death'
        
        elif action == "tell a joke":
            print(dedent("""
                Lucky for you they made you learn Gothon insults in 
                the academy. You tell the one Gothon joke you know:
                Lbhe zbgure vf fb sng,jura fur fvgf nebhaq gur ubhfr,
                fur fvgf nebhaq gur ubfhr.The Gothon stops,tries
                not to laugh, then busts out laughing and can't move.
                While he's laughing you run up and shoot him square in 
                the head putting him down,then jump through the 
                Weapon Armory door.
            """))
            return 'laser_weapon_armory'
        
        else:
            print("DOES NOT COMPUTE!")
            return 'central_corridor'

然后我创建了中央走廊，这是游戏的开始。我把游戏的场景放在 Map 之前，是因为我需要在随后引用它们。你应该也看到了我在第4行用了 dedent 函数。稍后你可以尝试删除它，看看它会做什么。

剩余的游戏场景创建：

class LaserWeaponArmory(Scene):
    
    def enter(self):
        print(dedent("""
            You do a dive roll into the Weapon Armory, crouch and scan
            the room for more Gothons that might be hiding. It's dead
            quiet, too quiet. You stand up and run to the far side of
            the room and find the neutron bomb in its container.
            There's a keypad lock on the box and you need the code to
            get the bomb out. If you get the code wrong 10 times then
            the lock closes forever and you can't get the bomb. The
            code is 3 digits.
        """))
        
        code = f"{randint(1,9)}{randint(1,9)}{randint(1,9)}"
        guess = input("[keypad]> ")
        guesses = 0
        
        while guess != code and guesses < 10:
            print("BZZZZEDDD!")
            guesses += 1
            guess = input("[keypad]> ")
        
        if guess == code:
            print(dedent("""
                The container clicks open and the seal breaks, letting
                gas out. You grab the neutron bomb and run as fast as
                you can to the bridge where you must place it in the
                right spot.
            """))
            return 'the_bridge'
        else:
            print(dedent("""
                The lock buzzes one last time and then you hear a
                sickening melting sound as the mechanism is fused
                together. You decide to sit there, and finally the
                Gothons blow up the ship from their ship and you die.
            """))
            return 'death'

class TheBridge(Scene):
    
    def enter(self):
        print(dedent("""
            You burst onto the Bridge with the netron destruct bomb
            under your arm and surprise 5 Gothons who are trying to
            take control of the ship. Each of them has an even uglier
            clown costume than the last. They haven't pulled their
            weapons out yet, as they see the active bomb under your
            arm and don't want to set it off.
        """))
        
        action = input("> ")
        
        if action == "throw the bomb":
            print(dedent("""
                In a panic you throw the bomb at the group of Gothons
                and make a leap for the door. Right as you drop it a
                Gothon shoots you right in the back killing you. As
                you die you see another Gothon frantically try to
                disarm the bomb. You die knowing they will probably
                blow up when it goes off.
            """))
            return 'death'
        
        elif action == "slowly place the bomb":
            print(dedent("""
                You point your blaster at the bomb under your arm and
                the Gothons put their hands up and start to sweat.
                You inch backward to the door, open it, and then
                carefully place the bomb on the floor, pointing your
                blaster at it. You then jump back through the door,
                punch the close button and blast the lock so the
                Gothons can't get out. Now that the bomb is placed
                you run to the escape pod to get off this tin can.
            """))
            return 'escape_pod'
        
        else:
            print("DOES NOT COMPUTE!")
            return 'the_bridge'

class EscapedPod(Scene):
    
    def enter(self):
        print(dedent("""
            You rush through the ship desperately trying to make it
            the escape pod before the whole ship explodes. It seems
            like hardly any Gothons are on the ship, so your run is
            clear of interference. You get to the chamber with the
            escape pods, and now need to pick one to take. Some of
            them could be damaged but you don't have time to look.
            There's 5 pods, which one do you take?
        """))
        
        good_pod = randint(1,5)
        guess = input("[pod #]> ")
        
        if int(guess) != good_pod:
            print(dedent("""
                You jump into pod {guess} and hit the eject button.
                The pod escapes out into the void of space, then
                implodes as the hull ruptures, crushing your body into
                jam jelly.
            """))
            return 'death'
        else:
            print(dedent("""
                You jump into pod {guess} and hit the eject button.
                The pod easily slides out into space heading to the
                planet below. As it flies to the planet, you look
                back and see your ship implode then explode like a
                bright star, taking out the Gothon ship at the same
                time. You won!
            """))
            return 'finished'

class Finished(Scene):
    
    def enter(self):
        print("You won! Good job.")
        return 'finished'

这是游戏的剩余场景，因为我知道我需要它们，并且已经想过它们之间如何流转，所以我能直接把代码写出来。

顺便说一句，我不会把所有这些代码都输入进去。还记得我说过要循序渐进，一点一点来。现在我只给你们看最后的结果。

Map地图类创建部分：

class Map(object):
    
    scenes = {
        'central_corridor':CentralCorridor(),
        'laser_weapon_armory':LaserWeaponArmory(),
        'the_bridge':TheBridge(),
        'escape_pod':EscapedPod(),
        'death':Death(),
        'finished':Finished(),
    }
    
    def __init__(self,start_scene):
        self.start_scene = start_scene
    
    def next_scene(self,scene_name):
        val = Map.scenes.get(scene_name)
        return val
    
    def opening_scene(self):
        return self.next_scene(self.start_scene)

然后是我的 Map 类，你可以看到它把每个场景的名字存储在一个字典里，然后我用Map.scenes 引用那个字典。这也是为什么地图出现在场景之后的原因，因为字典必须引用场

景，所以场景必须先存在。

启动游戏部分/实例化/调用过程：

a_map = Map('central_corridor')
a_game = Engine(a_map)
a_game.play()

最后是我通过制作地图来运行游戏的代码，在调用 play 使游戏工作之前，我把地图交给了引擎。 

ex43.py完整代码：

from sys import exit
from random import randint
from textwrap import dedent

class Scene(object):
    
    def enter(self):
        print("This scene is not yet configured.")
        print("Subclass it and implement enter().")
        exit(1)

class Engine(object):
    
    def __init__(self,scene_map):
        self.scene_map = scene_map
        
    def play(self):
        current_scene = self.scene_map.opening_scene()
        last_scene = self.scene_map.next_scene('finished')
        
        while current_scene != last_scene:
            next_scene_name = current_scene.enter()
            current_scene = self.scene_map.next_scene(next_scene_name)
        
        # be sure to print out the last scene
        current_scene.enter()

class Death(Scene):
    
    quips = [
        "You died.You kinda suck at this.",
        "Your Mom would be proud...if she ware smarter.",
            "Such a     luser.",
            "I have     a small puppy that's better at this.",
            "You're     worse than your Dad's jokes."
    ]
    
    def enter(self):
        print(Death.quips[randint(0,len(self.quips)-1)])
        exit(1)

class CentralCorridor(Scene):
    
    def enter(self):
        print(dedent("""
            The Gothons of Planet Percal #25 have invaded your ship and
            destroyed your entire crew.You are the last surviving
            member and your last mission is to get the neutron destruct
            bomb from the weapons Armory,put it in the bridge,and 
            blow the ship up after getting into an escape pod.
            
            You're running down the central corridor to the Weapons
            Armory when a Gothon jumps out,red scaly skin,dark grimy
            teeth,and evil clown costume flowing around his hate
            filled body.He's blocking the door to the Armory and
            about to pull a weapon to blast you.
        """))
        
        action = input("> ")
        
        if action == "shoot!":
            print(dedent("""
                Quick on the draw you yank out your blaster and fire
                it an the Gothon. His clown costume is flowing and
                moving around his body,which throws off your aim.
                Your laser hits his costume but misses him entirely.
                This completely ruins his brand new costume his mother
                bought him,which makes him fly into an insame rage
                and blast you repeatedly in the face until you are 
                dead.Then he eats you.
            """))
            return 'death'
        
        elif action == "dodge!":
            print(dedent("""
                Like a word class boxer you dodge,weave,slip and
                slide right as the Gothon's blaster cranks a laser
                past your head.In the middle of your artful dodge
                your foot slips and you bang your head on the metal
                wall and pass out.You wake up shortly after only to
                die as the Gothon stomps on your head and eats you.
            """))
            return 'death'
        
        elif action == "tell a joke":
            print(dedent("""
                Lucky for you they made you learn Gothon insults in 
                the academy. You tell the one Gothon joke you know:
                Lbhe zbgure vf fb sng,jura fur fvgf nebhaq gur ubhfr,
                fur fvgf nebhaq gur ubfhr.The Gothon stops,tries
                not to laugh, then busts out laughing and can't move.
                While he's laughing you run up and shoot him square in 
                the head putting him down,then jump through the 
                Weapon Armory door.
            """))
            return 'laser_weapon_armory'
        
        else:
            print("DOES NOT COMPUTE!")
            return 'central_corridor'

class LaserWeaponArmory(Scene):
    
    def enter(self):
        print(dedent("""
            You do a dive roll into the Weapon Armory, crouch and scan
            the room for more Gothons that might be hiding. It's dead
            quiet, too quiet. You stand up and run to the far side of
            the room and find the neutron bomb in its container.
            There's a keypad lock on the box and you need the code to
            get the bomb out. If you get the code wrong 10 times then
            the lock closes forever and you can't get the bomb. The
            code is 3 digits.
        """))
        
        code = f"{randint(1,9)}{randint(1,9)}{randint(1,9)}"
        guess = input("[keypad]> ")
        guesses = 0
        
        while guess != code and guesses < 10:
            print("BZZZZEDDD!")
            guesses += 1
            guess = input("[keypad]> ")
        
        if guess == code:
            print(dedent("""
                The container clicks open and the seal breaks, letting
                gas out. You grab the neutron bomb and run as fast as
                you can to the bridge where you must place it in the
                right spot.
            """))
            return 'the_bridge'
        else:
            print(dedent("""
                The lock buzzes one last time and then you hear a
                sickening melting sound as the mechanism is fused
                together. You decide to sit there, and finally the
                Gothons blow up the ship from their ship and you die.
            """))
            return 'death'

class TheBridge(Scene):
    
    def enter(self):
        print(dedent("""
            You burst onto the Bridge with the netron destruct bomb
            under your arm and surprise 5 Gothons who are trying to
            take control of the ship. Each of them has an even uglier
            clown costume than the last. They haven't pulled their
            weapons out yet, as they see the active bomb under your
            arm and don't want to set it off.
        """))
        
        action = input("> ")
        
        if action == "throw the bomb":
            print(dedent("""
                In a panic you throw the bomb at the group of Gothons
                and make a leap for the door. Right as you drop it a
                Gothon shoots you right in the back killing you. As
                you die you see another Gothon frantically try to
                disarm the bomb. You die knowing they will probably
                blow up when it goes off.
            """))
            return 'death'
        
        elif action == "slowly place the bomb":
            print(dedent("""
                You point your blaster at the bomb under your arm and
                the Gothons put their hands up and start to sweat.
                You inch backward to the door, open it, and then
                carefully place the bomb on the floor, pointing your
                blaster at it. You then jump back through the door,
                punch the close button and blast the lock so the
                Gothons can't get out. Now that the bomb is placed
                you run to the escape pod to get off this tin can.
            """))
            return 'escape_pod'
        
        else:
            print("DOES NOT COMPUTE!")
            return 'the_bridge'

class EscapedPod(Scene):
    
    def enter(self):
        print(dedent("""
            You rush through the ship desperately trying to make it
            the escape pod before the whole ship explodes. It seems
            like hardly any Gothons are on the ship, so your run is
            clear of interference. You get to the chamber with the
            escape pods, and now need to pick one to take. Some of
            them could be damaged but you don't have time to look.
            There's 5 pods, which one do you take?
        """))
        
        good_pod = randint(1,5)
        guess = input("[pod #]> ")
        
        if int(guess) != good_pod:
            print(dedent("""
                You jump into pod {guess} and hit the eject button.
                The pod escapes out into the void of space, then
                implodes as the hull ruptures, crushing your body into
                jam jelly.
            """))
            return 'death'
        else:
            print(dedent("""
                You jump into pod {guess} and hit the eject button.
                The pod easily slides out into space heading to the
                planet below. As it flies to the planet, you look
                back and see your ship implode then explode like a
                bright star, taking out the Gothon ship at the same
                time. You won!
            """))
            return 'finished'

class Finished(Scene):
    
    def enter(self):
        print("You won! Good job.")
        return 'finished'

class Map(object):
    
    scenes = {
        'central_corridor':CentralCorridor(),
        'laser_weapon_armory':LaserWeaponArmory(),
        'the_bridge':TheBridge(),
        'escape_pod':EscapedPod(),
        'death':Death(),
        'finished':Finished(),
    }
    
    def __init__(self,start_scene):
        self.start_scene = start_scene
    
    def next_scene(self,scene_name):
        val = Map.scenes.get(scene_name)
        return val
    
    def opening_scene(self):
        return self.next_scene(self.start_scene)

a_map = Map('central_corridor')
a_game = Engine(a_map)
a_game.play()

五 代码中涉及到的知识

 1 sys.exit(n) 

功能：执行到主程序末尾，解释器自动退出，但是如果需要中途退出程序，可以调用sys.exit函数，带有一个可选的整数参数返回给调用它的程序，表示你可以在主程序中捕获对sys.exit的调用。（0是正常退出，其他为异常）

有关sys模块的其它内容可参考：https://www.cnblogs.com/cherishry/p/5725184.html

2 textwrap.dedent()函数

功能：去除缩进

有关textwrap模块的其它内容，可参考：https://www.cnblogs.com/wj5633/p/6931187.html

3 代码详解

from sys import exit                                         # 导入exit()方法，用来控制程序的结束时间
from random import randint                                   # 导入randint()方法产生随机整数
from textwrap import dedent                                  # 导入dedent()方法去除缩进

# 定义场景基类
class Scene(object):
    
    def enter(self):
        print("This scene is not yet configured.")
        print("Subclass it and implement enter().")
        exit(1)

# 程序运行的主体部分Engine类
class Engine(object):
    
    def __init__(self,scene_map):                              # 在创建Engine类的对象a_game的过程中，已经将Map类的对象a_map的值传给了参数scene_map
        self.scene_map = scene_map                             # 将a_map的值传给self.scene_map,相当于创建了一个新的Map类的对象
        # print(f"self.scene_map = {self.scene_map}
")
        
    def play(self):                                            # 通过Engine类的对象a_game调用Engine类的方法play，开始游戏：
        # print(f"self.scene_map.start_scene = {self.scene_map.start_scene}
")
        current_scene = self.scene_map.opening_scene()         # 通过Map类的对象self.scene_map调用opening_scene()，得到返回值val(此时为类CentralCorridor()的对象)；
        # print(f"current_scene1 = {current_scene}
")         # 通过将val的值赋给current_scene把它初始化为类CentralCorridor()的对象
        last_scene = self.scene_map.next_scene('finished')     # 通过Map类的对象self.scene_map调用next_scene()方法，得到返回值val(此时为类Finished()的对象)
        # print(f"last_scene = {last_scene}
")                # 通过将val的值赋给last_scene把它初始化为类Finished()的对象
        
        while current_scene != last_scene:
            next_scene_name = current_scene.enter() # 通过类CentralCorridor()的对象current_scene调用类CentralCorridor()中的方法enter(),并将函数返回值赋给next_scene_name变量
            # print(f"next_scene_name = {next_scene_name}
")
            current_scene = self.scene_map.next_scene(next_scene_name)# 通过Map类的对象self.scene_map调用Map类中的方法，将current_scene初始化为新的场景类的对象
            # print(f"current_scene2 = {current_scene}
")
            
        # be sure to print out the last scene
        current_scene.enter()
        # print(f"current_scene3 = {current_scene}
")

# 只要出错，就会触发Death()类
class Death(Scene):
    
    quips = [
        "You died.You kinda suck at this.",
        "Your Mom would be proud...if she ware smarter.",
            "Such a     luser.",
            "I have     a small puppy that's better at this.",
            "You're     worse than your Dad's jokes."
    ]
    
    def enter(self):
        print(Death.quips[randint(0,len(self.quips)-1)])      # 通过生成随机数的方式任意返回列表quips中的一个元素
        exit(1)

# 程序运行的初始场景，通过a_map = Map('central_corridor')语句第一次进入
class CentralCorridor(Scene):
    
    def enter(self):
        print(dedent("""
            The Gothons of Planet Percal #25 have invaded your ship and
            destroyed your entire crew.You are the last surviving
            member and your last mission is to get the neutron destruct
            bomb from the weapons Armory,put it in the bridge,and 
            blow the ship up after getting into an escape pod.
            
            You're running down the central corridor to the Weapons
            Armory when a Gothon jumps out,red scaly skin,dark grimy
            teeth,and evil clown costume flowing around his hate
            filled body.He's blocking the door to the Armory and
            about to pull a weapon to blast you.
        """))
        
        action = input("> ")                      # 根据用户的输入，执行不同的语句，返回不同的结果
        
        if action == "shoot!":
            print(dedent("""
                Quick on the draw you yank out your blaster and fire
                it an the Gothon. His clown costume is flowing and
                moving around his body,which throws off your aim.
                Your laser hits his costume but misses him entirely.
                This completely ruins his brand new costume his mother
                bought him,which makes him fly into an insame rage
                and blast you repeatedly in the face until you are 
                dead.Then he eats you.
            """))
            return 'death'                        # 如果用户输入的操作为"shoot!",将'death'字符串变量返回给a_map
        
        elif action == "dodge!":
            print(dedent("""
                Like a word class boxer you dodge,weave,slip and
                slide right as the Gothon's blaster cranks a laser
                past your head.In the middle of your artful dodge
                your foot slips and you bang your head on the metal
                wall and pass out.You wake up shortly after only to
                die as the Gothon stomps on your head and eats you.
            """))
            return 'death'                        # 如果用户输入的操作为"dodge!",将'death'字符串变量返回给a_map
        
        elif action == "tell a joke":
            print(dedent("""
                Lucky for you they made you learn Gothon insults in 
                the academy. You tell the one Gothon joke you know:
                Lbhe zbgure vf fb sng,jura fur fvgf nebhaq gur ubhfr,
                fur fvgf nebhaq gur ubfhr.The Gothon stops,tries
                not to laugh, then busts out laughing and can't move.
                While he's laughing you run up and shoot him square in 
                the head putting him down,then jump through the 
                Weapon Armory door.
            """))
            # print(f"a_map2 = {a_map}
")
            return 'laser_weapon_armory'           # 如果用户输入的操作为"tell a joke",将'laser_weapon_armory'字符串变量返回给a_map
        
        else:
            print("DOES NOT COMPUTE!")
            return 'central_corridor'              # 其它情况，返回'central_corridor'，重新匹配

# LaserWeaponArmory()场景只有在用户动作为"tell a joke"的情况下才会触发
class LaserWeaponArmory(Scene):                    # 通过Engine类中的current_scene = self.scene_map.opening_scene()语句进入该场景
    
    def enter(self):
        print(dedent("""
            You do a dive roll into the Weapon Armory, crouch and scan
            the room for more Gothons that might be hiding. It's dead
            quiet, too quiet. You stand up and run to the far side of
            the room and find the neutron bomb in its container.
            There's a keypad lock on the box and you need the code to
            get the bomb out. If you get the code wrong 10 times then
            the lock closes forever and you can't get the bomb. The
            code is 3 digits.
        """))
        
        code = f"{randint(1,9)}{randint(1,9)}{randint(1,9)}"
        print(f"code = {code}
")
        guess = input("[keypad]> ")                          # 用户输入不同的keypad，猜谜
        guesses = 0
        
        while guess != code and guesses < 10:                # 保证用户有10次猜谜机会，否则执行else语句
            print("BZZZZEDDD!")
            guesses += 1
            guess = input("[keypad]> ")
        
        if guess == code:                                    # 如果用户猜中了，返回字符串'the_bridge'给对象current_scene
            print(dedent("""
                The container clicks open and the seal breaks, letting
                gas out. You grab the neutron bomb and run as fast as
                you can to the bridge where you must place it in the
                right spot.
            """))
            return 'the_bridge'
        else:
            print(dedent("""
                The lock buzzes one last time and then you hear a
                sickening melting sound as the mechanism is fused
                together. You decide to sit there, and finally the
                Gothons blow up the ship from their ship and you die.
            """))
            return 'death'                                   # 用户猜了10次还是没有猜中，返回字符串'death'给对象current_scene

# TheBridge()场景只有在用户成功进入LaserWeaponArmory()场景并且在猜谜游戏中猜中才会触发
class TheBridge(Scene):
    
    def enter(self):
        print(dedent("""
            You burst onto the Bridge with the netron destruct bomb
            under your arm and surprise 5 Gothons who are trying to
            take control of the ship. Each of them has an even uglier
            clown costume than the last. They haven't pulled their
            weapons out yet, as they see the active bomb under your
            arm and don't want to set it off.
        """))
        
        action = input("> ")
        
        if action == "throw the bomb":
            print(dedent("""
                In a panic you throw the bomb at the group of Gothons
                and make a leap for the door. Right as you drop it a
                Gothon shoots you right in the back killing you. As
                you die you see another Gothon frantically try to
                disarm the bomb. You die knowing they will probably
                blow up when it goes off.
            """))
            return 'death'
        
        elif action == "slowly place the bomb":
            print(dedent("""
                You point your blaster at the bomb under your arm and
                the Gothons put their hands up and start to sweat.
                You inch backward to the door, open it, and then
                carefully place the bomb on the floor, pointing your
                blaster at it. You then jump back through the door,
                punch the close button and blast the lock so the
                Gothons can't get out. Now that the bomb is placed
                you run to the escape pod to get off this tin can.
            """))
            return 'escape_pod'
        
        else:
            print("DOES NOT COMPUTE!")
            return 'the_bridge'

# EscapedPod()场景只有在用户成功触发TheBridge()场景并且输入动作为"slowly place the bomb"的情况下才会触发
class EscapedPod(Scene):
    
    def enter(self):
        print(dedent("""
            You rush through the ship desperately trying to make it
            the escape pod before the whole ship explodes. It seems
            like hardly any Gothons are on the ship, so your run is
            clear of interference. You get to the chamber with the
            escape pods, and now need to pick one to take. Some of
            them could be damaged but you don't have time to look.
            There's 5 pods, which one do you take?
        """))
        
        good_pod = randint(1,5)
        print(f"good_pod = {good_pod}
")
        guess = input("[pod #]> ")
        
        if int(guess) != good_pod:
            print(dedent("""
                You jump into pod {guess} and hit the eject button.
                The pod escapes out into the void of space, then
                implodes as the hull ruptures, crushing your body into
                jam jelly.
            """))
            return 'death'
        else:
            print(dedent("""
                You jump into pod {guess} and hit the eject button.
                The pod easily slides out into space heading to the
                planet below. As it flies to the planet, you look
                back and see your ship implode then explode like a
                bright star, taking out the Gothon ship at the same
                time. You won!
            """))
            return 'finished'

# Finished()场景的触发条件：用户选择流程："tell a joke"——猜谜成功（是否等于code变量的值）——"slowly place the bomb"——再次猜谜成功（是否等于good_pod变量的值）
class Finished(Scene):
    
    def enter(self):
        print("You won! Good job.")
        return 'finished'

class Map(object):
    
    scenes = {
        'central_corridor':CentralCorridor(),
        'laser_weapon_armory':LaserWeaponArmory(),
        'the_bridge':TheBridge(),
        'escape_pod':EscapedPod(),
        'death':Death(),
        'finished':Finished(),
    }
    
    def __init__(self,start_scene):
        self.start_scene = start_scene
        # print(f"self.start_scene = {self.start_scene}
")
    
    def next_scene(self,scene_name):
        val = Map.scenes.get(scene_name)
        # print(f"val = {val}
")
        return val
    
    def opening_scene(self):
        return self.next_scene(self.start_scene)

a_map = Map('central_corridor')         # a_map是Map类的一个对象，此时完成的操作是：
# print(f"a_map1 = {a_map}
")          # （1）将'central_corridor'传给参数start_scene，并将其赋值给self.start_scene变量
                                        # （2）然后通过opening_scene()方法调用next_scene()方法，通过变量self.start_scene将'central_corridor'传给参数scene_name
                                        # （3）在next_scene方法内部，通过调用Map类的字典变量scenes的内置方法get，得到键'central_corridor'
                                        #      对应的值CentralCorridor()，然后将val初始化为类CentralCorridor()的对象
a_game = Engine(a_map)                  # a_game是Engine()类的一个对象，此时完成的操作是：
# print(f"a_game = {a_game}
")         # （1）将Map类的对象a_map的地址作为参数传给Engine()类中构造方法的参数scene_map
a_game.play()                           # 通过Engine类的对象a_game调用Engine类的方法play，开始游戏：

运行结果：

PS E:6_AI-Study1_Python2_code_python2_LearnPythonTheHardWay> python ex43.py

The Gothons of Planet Percal #25 have invaded your ship and
destroyed your entire crew.You are the last surviving
member and your last mission is to get the neutron destruct
bomb from the weapons Armory,put it in the bridge,and
blow the ship up after getting into an escape pod.

You're running down the central corridor to the Weapons
Armory when a Gothon jumps out,red scaly skin,dark grimy
teeth,and evil clown costume flowing around his hate
filled body.He's blocking the door to the Armory and
about to pull a weapon to blast you.

> tell a joke

Lucky for you they made you learn Gothon insults in
the academy. You tell the one Gothon joke you know:
Lbhe zbgure vf fb sng,jura fur fvgf nebhaq gur ubhfr,
fur fvgf nebhaq gur ubfhr.The Gothon stops,tries
not to laugh, then busts out laughing and can't move.
While he's laughing you run up and shoot him square in
the head putting him down,then jump through the
Weapon Armory door.


You do a dive roll into the Weapon Armory, crouch and scan
the room for more Gothons that might be hiding. It's dead
quiet, too quiet. You stand up and run to the far side of
the room and find the neutron bomb in its container.
There's a keypad lock on the box and you need the code to
get the bomb out. If you get the code wrong 10 times then
the lock closes forever and you can't get the bomb. The
code is 3 digits.

code = 839

[keypad]> 839

The container clicks open and the seal breaks, letting
gas out. You grab the neutron bomb and run as fast as
you can to the bridge where you must place it in the
right spot.


You burst onto the Bridge with the netron destruct bomb
under your arm and surprise 5 Gothons who are trying to
take control of the ship. Each of them has an even uglier
clown costume than the last. They haven't pulled their
weapons out yet, as they see the active bomb under your
arm and don't want to set it off.

> slowly place the bomb

You point your blaster at the bomb under your arm and
the Gothons put their hands up and start to sweat.
You inch backward to the door, open it, and then
carefully place the bomb on the floor, pointing your
blaster at it. You then jump back through the door,
punch the close button and blast the lock so the
Gothons can't get out. Now that the bomb is placed
you run to the escape pod to get off this tin can.


You rush through the ship desperately trying to make it
the escape pod before the whole ship explodes. It seems
like hardly any Gothons are on the ship, so your run is
clear of interference. You get to the chamber with the
escape pods, and now need to pick one to take. Some of
them could be damaged but you don't have time to look.
There's 5 pods, which one do you take?

good_pod = 4

[pod #]> 4

You jump into pod {guess} and hit the eject button.
The pod easily slides out into space heading to the
planet below. As it flies to the planet, you look
back and see your ship implode then explode like a
bright star, taking out the Gothon ship at the same
time. You won!

You won! Good job.