Quote:
But, it seems to be giving me a memory location of the key instead of the value (name and description of the room/player/item).

class Room:    # ...previous stuff here...    def __str__(self):        return self.roomname + '\n' + self.roomdesc

Quote:Original post by Zahlman
Like Fruny said, Python dictionaries (and lists and tuples) don't care about what they contain: they are 'heterogenous containers'. So if you really wanted a dictionary of dictionaries, you could do that quite easily, because a dictionary is a kind of object, and any object can be a dictionary value.

That said, it sounds like your confusion has more to do with modelling the situation than the syntax of implementing that model :)

First off, when you talk about "IDs", this implies a separate object from the thing being ID'd. That's fine, but you probably only want a name in the ID, leaving the description in the thing being IDd.

We have four sorts of things:

- player
- player ID
- room
- room ID

Because the IDs are just names, we could just use strings for them. The player and room both aggregate some information and will have some behaviour, so it makes sense to define classes for them.

Now, a room might contain players, and similarly a player knows about the room that s/he's in. We don't actually need IDs to handle this, because what we'll do is make each room track a list of the contained players, and have each player remember the containing room directly. There's a bit of a trick here: because of how Python stores objects, you don't really distinguish between object members that are "contained" and object members that are "known about" in the syntax - it's a matter of semantics.

So, we do something like:

class Room:  def __init__(self):    self.players = [] # will be Players that are "contained"class Player:  def __init__(self, location):    self.location = location # will be a Room that is "known about" (containing)

Note that the Room won't *actually* "contain" Players, but instead points to them, in the same way that the Player points to its containing room. Hence the semantics. :)

Now, we just add the functionality to move a Player from one room to the next. We should also make sure that the Player's initial Room knows about the Player, so we'll adjust the constructor as well. We can make this more foolproof by setting an invalid location first, and then "moving" the player into the initial Room.

class Room:  def __init__(self):    self.players = []  def removePlayer(self, player):    # I don't remember if this throws an exception or returns -1 for not found    # So adjust as needed :)    index = self.players.find(player)    if (index != -1) : del self.players[index]  def addPlayer(self, player):    self.players.append(player)class Player:  def __init__(self, location):    self.location = None    self.moveTo(location)  def moveTo(self, location):    if self.location is not None:      # excuse myself from the current room, if any      self.location.removePlayer(self)      # and go to the new one.      location.addPlayer(self)      self.location = location

class Room:        def __init__(self, roomname, roomdesc):                self.roomname = roomname                self.roomdesc = roomdesc                self.players = []                       # players contained in this room        def removePlayer(self, player):                index = self.players.remove(player)     # removes player (using playerID) from the room (when player leaves)        def addPlayer(self, player):                    # adds player to the room (when player enters)                self.players.append(player)        def __str__(self):                return self.roomname + ": " + self.roomdesc  # prints out the room name and room descriptionclass Player:        def __init__(self, playername, playerdesc, location):                self.playername = playername                self.playerdesc = playerdesc                self.location = 0                               # default starting room of all players (roomID = 0)                self.moveTo(location)                           # location of player. ie what room he/she is in        def moveTo(self, location):                if location != 0:                        self.location.removePlayer(self)                # remove player from original room                        location.addPlayer(self)                        # add player to new room                        self.location = location                        # update player room location        def __str__(self):                return self.playername + ": " + self.playerdesc

Quote:Original post by fengx
Yes, you are correct that it is assigned an int type. Before the error, self.location contains the default value of 0.

Quote:But, looking at my input command, I assign it a 3, yet this value is not passed. It also will not recognize the self.location.removePlayer and location.addPlayer functions?

class Player:        def __init__(self, playername, playerdesc, location = None):                self.playername = playername                self.playerdesc = playerdesc                self.location = location                self.moveTo(location)                           # location of player. ie what room he/she is in        def moveTo(self, location):                if location:                                    # fails on <None>                        self.location.removePlayer(self)        # remove player from original room                        location.addPlayer(self)                # add player to new room                        self.location = location                        # update player room location

basement = Room()p = Player("Hero", "A valorous knight", basement)