Vfrdtyky

From learningpythonthehardway, I've reached the text adventure game and I had a few codes that I understand what they execute, but I don't understand how. Below is the whole code I made smaller into a single .py file:

from sys import exit 

from random import randint



class Scene(object):

    def enter(self):

        print "This isn't configured yet. Subclass and implement enter()"

        exit(1)



class CentralCorridor(Scene):



    def enter(self):

        print "Something."

    action = raw_input("> ")



    if action == "shoot!":

        print "Something something."



        return 'death'





class Death(Scene):



    dead = [

    "You died. That sucks ...",

    "You shouldn't have died here...that was dumb.",

    "You L00se.",

    "Even a cow's moo sounds smarter than you."

    ]



    def enter(self):

        print Death.dead[randint(0, len(self.dead)-1)]

        exit(1)



class Engine(object):



    def __init__(self, scene_map):

        self.scene_map = scene_map #sets scene_map from the a_map variable



    def play(self):

        current_scene = self.scene_map.opening_scene()#sets aMap.opening_scene() and initiates CentralCorridor

        last_scene = self.scene_map.next_scene('finished') #for the last win scene Finished()

        while current_scene != last_scene:

            next_scene_name = current_scene.enter() #if scene's not last, call enter() of current scene to next scene name

            current_scene = self.scene_map.next_scene(next_scene_name)#Set current_scene to instance of scene_map with self, next_scene_name as parameters



        current_scene.enter()



class Map(object): #initially central_corridor



    scenes = {  

        'central_corridor':CentralCorridor(),   

        'death':Death(),

        }



    def __init__(self, start_scene):

        self.start_scenes = start_scene #central_corridor





    def next_scene(self, scene_name):

        val = Map.scenes.get(scene_name) #sets CentralCorridor() to val

        return val



    def opening_scene(self):

        return self.next_scene(self.start_scenes) #returns val from 

                                            #next_scene which is 

                                            #CentralCorridor()





a_map = Map('central_corridor')

a_game = Engine(a_map)

a_game.play()

In this code, I have a few things I don't get (bear with me.)

1. How does " return 'death' " under the CentralCorridor class refer to the dictionary down in Map class's scenes, and return Death class? When I type shoot! it seems to go through the Engine class and execute the current_scene.enter() but I haven't called the Engine class's play function anywhere in the CentralCorridor class.




2. In the Map class's opening_scene function, how exactly is
   return self.next_scene(self.start_scenes) working??? I know what it does, but the self.next_scene(self.start_scenes) bit is slightly confusing me.

Thank you for anyone explaining this!

You call the play() function in the very last line of your code: a_game.play()

def opening_scene(self):

    # This call the next_scene method with the parameter start_scenes. 

    # which is initialize to 'central_corridor' when you create the object

    # with Map('central_corridor') a few lines below

    return self.next_scene(self.start_scenes) 





def next_scene(self, scene_name):

    # This get the value for key 'central_corridor' from 

    # the scenes dictionary and assign it to variable val.

    val = Map.scenes.get(scene_name) 

    return val

I have also just reach this exercise few days ago in the book, spend some time looking for answer. This website is really nice tho. Let me try to explain as it strengthen my understanding. Please feel free to correct me if I'm wrong at any point.

Answering your question, I might as well explaining the whole thing start with:

a_map = Map('central_corridor')

a_game = Engine(a_map)

a_game.play()

a_map is-a Map that takes 'central corridor' as parameter.

In class Map (read the # comment)

def __init__(self, start_scene):

    self.start_scenes = start_scene  #start_scene is set to 'central corridor'



def next_scene(self, scene_name):

    val = Map.scenes.get(scene_name) #get() narrows the search in the library scenes.

    return val #return and pass to next_scene as a method.

def opening_scene(self):

    return self.next_scene(self.start_scenes) #return and pass to opening_scene

as self.start_scene was set as parameter 'central corridor' thus, opening_scene will search 'central corridor' in scenes library located in class Map by method stated in next_scene, which is get() a function used to locate things in library. Continue on...

a_game = Engine(a_map)

a_game is-a Engine that takes a_map as parameter, while a_map takes 'central corridor' as parameter thus a_game takes 'central corridor' as parameters as well. Logic A=B and B=C thus A=C. and also a_game has access to both class Map and Engine as inheritance. You can read about it in the next chapter in the book learningpythonthehardway after this chapter.

In class Engine (read the # comment)

def __init__(self, scene_map):

    self.scene_map = scene_map #self.scene_map has set to 'central corridor'

def play(self):

    current_scene = self.scene_map.opening_scene() #set current_scene by calling the function opening_scene which was explain in class Map, accessible by a_game

    last_scene = self.scene_map.next_scene('finished') #set last_scene by searching scene in class Map.

    #I didn't see any 'finish' scene in map, I think you should have added it in scenes.

Note Here! you will get a return from the enter function.

    while current_scene != last_scene: #enters the while loop!! This is where the game starts.

        next_scene_name = current_scene.enter()

        current_scene = self.scene_map.next_scene(next_scene_name) 



    current_scene.enter()

Well here is the critical point to understand the whole game process.

next_scene_name = current_scene.enter()

Now you are inside the function CentralCorridor(), and you make your choices. Because your codes are not complete, so in this case we assume action == 'shoot!' which gets you 'death' as return and pass this to next_scene_name. Now next_scene_name has set to 'death'. You may have other scenes to be set if you make other choices here (if you code them).

Then

current_scene = self.scene_map.next_scene(next_scene_name)

Set current_scene by searching the scene in class Map using next_scene function which was explained earlier. In this case, searching the return from CentralCorridor() which is 'death', will get you the function death() in library scenes located in class Map.

The game continues as while loops current_scene != last_scene. That's why u need a 'finished' scene in scenes library.

To understand the code, you need to understand what the last three lines of the code and what they actually do:

a_map = Map('central_corridor')

a_game = Engine(a_map)

a_game.play()

The object a_map is first created which is-a class Map. Map is called with the argument central_corridor, which is a key to a dictionary that holds the value CentrolCorridor(). CentralCorridor() is a class which inherits from the class Scene.

With this information, lets understand what the object a_map now actually holds. The object a_map can access the everything with the class Map. The object also directed to the class CentralCorridor and can access every method and variable there. Remember that cCentralCorridor inherits from the class Scene, meaning it can too access variables and methods in Scene.

Now lets understand the object a_game. This object is an Engine class object. The Engine class, on the other hand, has the argument a_map. The a_map, as we have seen is an object that can access various methods and variables in a number of classes as discussed above. It is now possible to access the play method in Engine, ie a_game.play(). Keenly this can help you understand and respond to your first questions. Just take time to understand how everything merges out and connects to each other.
On the second question, in fact a proper understanding of the above can help you understand how everything couples up in the Engine class. return self.next_scene(self.start_scenes)holds the initial argument central_corridor. After executing the next value that is picked by the code val = Map.scenes.get(scene_name) Therefore, the code return val takes the code to the new scene, which is the class Death.