Initial commit

+
+class CommandHandler(object):
+
+  def tokenize_params(self):
+    cleaned = self.params.lower().strip()
+    tokens = []
+    for token in cleaned.split(' '):
+        token = token.strip()
+        if len(token) > 0:
+            tokens.append(token)
+    self.tokens = tokens
+
+  def look(self):
+    self.mud.send_message(self.id, "")
+    if len(self.tokens) > 0 and self.tokens[0] == 'at':
+        del self.tokens[0]
+    if len(self.tokens) == 0:
+        self.mud.send_message(self.id, self.room.get_description())
+    else:
+        subject = self.tokens[0]
+        items = self.room.get_look_items()
+        for item in items:
+            if subject in item:
+                self.mud.send_message(self.id, items[item])
+                return True
+        self.mud.send_message(self.id, "That doesn't seem to be here.")
+
+    playershere = []
+    # go through every player in the game
+    for pid, pl in self.players.items():
+        # if they're in the same room as the player
+        if self.players[pid]["room"] == self.players[self.id]["room"]:
+            # ... and they have a name to be shown
+            if self.players[pid]["name"] is not None:
+                # add their name to the list
+                playershere.append(self.players[pid]["name"])
+
+    # send player a message containing the list of players in the room
+    self.mud.send_message(self.id, "Players here: {}".format(
+                                            ", ".join(playershere)))
+
+    # send player a message containing the list of exits from this room
+    self.mud.send_message(self.id, "Exits are: {}".format(
+                                  ", ".join(self.room.get_exits())))
+
+    return True
+
+  def parse(self, id, cmd, params, room, mud, players):
+    self.id = id
+    self.cmd = cmd
+    self.params = params
+    self.tokenize_params()
+    self.room = room
+    self.mud = mud
+    self.players = players
+
+    try:
+        method = getattr(self, cmd)
+        return method()
+    except AttributeError:
+        return False
+

+Commands:
+  say <message>  - Says something out loud, e.g. 'say Hello'
+  look           - Examines the surroundings, e.g. 'look'
+  go <exit>      - Moves through the exit specified, e.g. 'go outside'
+  save           - Saves your character
+  quit           - Saves your character then closes the connection
\ No newline at end of file

+#!/usr/bin/env python
+
+"""A simple Multi-User Dungeon (MUD) game. Players can talk to each
+other, examine their surroundings and move between rooms.
+
+Some ideas for things to try adding:
+    * More rooms to explore
+    * An 'emote' command e.g. 'emote laughs out loud' -> 'Mark laughs
+        out loud'
+    * A 'whisper' command for talking to individual players
+    * A 'shout' command for yelling to players in all rooms
+    * Items to look at in rooms e.g. 'look fireplace' -> 'You see a
+        roaring, glowing fire'
+    * Items to pick up e.g. 'take rock' -> 'You pick up the rock'
+    * Monsters to fight
+    * Loot to collect
+    * Saving players accounts between sessions
+    * A password login
+    * A shop from which to buy items
+
+author: Mark Frimston - mfrimston@gmail.com
+"""
+
+import time
+# import datetime
+#import io
+import json
+
+# import the MUD server class
+from mudserver import MudServer
+from commands import CommandHandler
+
+print('STARTING MUD\r\n\r\n\r\n')
+
+rooms = {}
+
+# stores the players in the game
+players = {}
+
+# start the server
+mud = MudServer()
+
+cmd_handler = CommandHandler()
+
+def load_room(room_name):
+    print("Loading room:" + room_name)
+    try:
+        if room_name in rooms:
+            return rooms[room_name]
+
+
+        module = __import__('rooms.' + room_name.lower())
+        room_module = getattr(module, room_name.lower())
+        room_class = getattr(room_module, room_name)
+        instance = room_class()
+        rooms[room_name] = instance
+
+        return instance
+    except Exception as e:
+        print(e)
+        return None
+
+def save_object_to_file(obj, filename):
+    with open(filename, 'w', encoding='utf-8') as f:
+      f.write(json.dumps(obj, ensure_ascii=False))
+
+def load_object_from_file(filename):
+    try:
+        with open(filename, 'r', encoding='utf-8') as f:
+            return json.loads(f.read())
+    except Exception:
+        return None
+
+def prompt(pid):
+    if "prompt" not in players[pid]:
+        players[pid]["prompt"] = "> "
+    mud.send_message(pid, "\r\n" + players[pid]["prompt"], '')
+
+# main game loop. We loop forever (i.e. until the program is terminated)
+while True:
+
+    # pause for 1/5 of a second on each loop, so that we don't constantly
+    # use 100% CPU time
+    time.sleep(0.001)
+
+    # TODO: Add some cache removal if older than X
+    # now = datetime.datetime.now()
+    # delta = now - datetime.timedelta(minutes = 2)
+    # for room in rooms:
+    #     if room.created < delta:
+    #         del rooms[room]
+
+    # 'update' must be called in the loop to keep the game running and give
+    # us up-to-date information
+    mud.update()
+
+    # go through any newly connected players
+    for id in mud.get_new_players():
+
+        # add the new player to the dictionary, noting that they've not been
+        # named yet.
+        # The dictionary key is the player's id number. We set their room to
+        # None initially until they have entered a name
+        # Try adding more player stats - level, gold, inventory, etc
+        players[id] = {
+            "name": None,
+            "room": None,
+            "inventory": None,
+            "prompt": "> ",
+        }
+
+        # send the new player a prompt for their name
+        mud.send_message(id, "What is your name?")
+
+    # go through any recently disconnected players
+    for id in mud.get_disconnected_players():
+
+        # if for any reason the player isn't in the player map, skip them and
+        # move on to the next one
+        if id not in players:
+            continue
+
+        # go through all the players in the game
+        for pid, pl in players.items():
+            # send each player a message to tell them about the diconnected
+            # player
+            mud.send_message(pid, "{} quit the game".format(
+                                                        players[id]["name"]))
+
+        # remove the player's entry in the player dictionary
+        del(players[id])
+
+    # go through any new commands sent from players
+    for id, command, params in mud.get_commands():
+
+        # if for any reason the player isn't in the player map, skip them and
+        # move on to the next one
+        if id not in players:
+            continue
+
+        if players[id]["room"]:
+            rm = load_room(players[id]["room"])
+        # if the player hasn't given their name yet, use this first command as
+        # their name and move them to the starting room.
+        if players[id]["name"] is None:
+
+            loaded_player = load_object_from_file("players/{}.json".format(command))
+            if loaded_player is None:            
+                players[id]["name"] = command
+                players[id]["room"] = "Tavern"
+            else:
+                players[id] = loaded_player
+
+            # go through all the players in the game
+            for pid, pl in players.items():
+                # send each player a message to tell them about the new player
+                mud.send_message(pid, "{} entered the game".format(
+                                                        players[id]["name"]))
+
+            # send the new player a welcome message
+            mud.send_message(id, "\r\n\r\nWelcome to the game, {}. ".format(
+                                                           players[id]["name"])
+                             + "\r\nType 'help' for a list of commands. Have fun!\r\n\r\n")
+
+            # send the new player the description of their current room
+            mud.send_message(id, load_room(players[id]["room"]).get_description())
+
+        # each of the possible commands is handled below. Try adding new
+        # commands to the game!
+
+        # 'help' command
+        elif command == "help":
+
+            with open('help/help.txt', 'r', encoding='utf-8') as f:
+                for line in f:
+                    mud.send_message(id, line, '\r')
+                mud.send_message(id, '')
+
+        # 'help' command
+        elif command == "quit":
+
+            # send the player back the list of possible commands
+            mud.send_message(id, "Saving...")
+            save_object_to_file(players[id], "players/{}.json".format(players[id]["name"]))
+            mud.disconnect_player(id)
+
+        # 'help' command
+        elif command == "save":
+
+            # send the player back the list of possible commands
+            mud.send_message(id, "Saving...")
+            save_object_to_file(players[id], "players/{}.json".format(players[id]["name"]))
+            mud.send_message(id, "Save complete")
+
+        # 'say' command
+        elif command == "say":
+
+            # go through every player in the game
+            for pid, pl in players.items():
+                # if they're in the same room as the player
+                if players[pid]["room"] == players[id]["room"]:
+                    # send them a message telling them what the player said
+                    mud.send_message(pid, "{} says: {}".format(
+                                                players[id]["name"], params))
+
+        # 'look' command
+        elif cmd_handler.parse(id, command, params, rm, mud, players):
+
+            pass
+
+        # 'go' command
+        elif command == "go":
+
+            # store the exit name
+            ex = params.lower()
+
+            # store the player's current room
+            rm = load_room(players[id]["room"])
+
+            # if the specified exit is found in the room's exits list
+            if ex in rm.get_exits():
+
+                # go through all the players in the game
+                for pid, pl in players.items():
+                    # if player is in the same room and isn't the player
+                    # sending the command
+                    if players[pid]["room"] == players[id]["room"] \
+                            and pid != id:
+                        # send them a message telling them that the player
+                        # left the room
+                        mud.send_message(pid, "{} left via exit '{}'".format(
+                                                      players[id]["name"], ex))
+
+                # update the player's current room to the one the exit leads to
+                loaded = load_room(rm.get_exits()[ex])
+                if loaded == None:
+                    mud.send_message(id, "An invisible force prevents you from going in that direction.")
+                    continue
+                else:
+                    players[id]["room"] = rm.get_exits()[ex]
+                    rm = loaded
+
+                # go through all the players in the game
+                for pid, pl in players.items():
+                    # if player is in the same (new) room and isn't the player
+                    # sending the command
+                    if players[pid]["room"] == players[id]["room"] \
+                            and pid != id:
+                        # send them a message telling them that the player
+                        # entered the room
+                        mud.send_message(pid,
+                                         "{} arrived via exit '{}'".format(
+                                                      players[id]["name"], ex))
+
+                # send the player a message telling them where they are now
+                mud.send_message(id, "You arrive at '{}'".format(rm.get_title()))
+
+            # the specified exit wasn't found in the current room
+            else:
+                # send back an 'unknown exit' message
+                mud.send_message(id, "Unknown exit '{}'".format(ex))
+
+
+        # some other, unrecognised command
+        else:
+            # send back an 'unknown command' message
+            mud.send_message(id, "Unknown command '{}'".format(command))
+        prompt(id)

+"""Basic MUD server module for creating text-based Multi-User Dungeon
+(MUD) games.
+
+Contains one class, MudServer, which can be instantiated to start a
+server running then used to send and receive messages from players.
+
+author: Mark Frimston - mfrimston@gmail.com
+"""
+
+
+import socket
+import select
+import time
+import sys
+
+
+class MudServer(object):
+    """A basic server for text-based Multi-User Dungeon (MUD) games.
+
+    Once created, the server will listen for players connecting using
+    Telnet. Messages can then be sent to and from multiple connected
+    players.
+
+    The 'update' method should be called in a loop to keep the server
+    running.
+    """
+
+    # An inner class which is instantiated for each connected client to store
+    # info about them
+
+    class _Client(object):
+        """Holds information about a connected player"""
+
+        # the socket object used to communicate with this client
+        socket = None
+        # the ip address of this client
+        address = ""
+        # holds data send from the client until a full message is received
+        buffer = ""
+        # the last time we checked if the client was still connected
+        lastcheck = 0
+
+        def __init__(self, socket, address, buffer, lastcheck):
+            self.socket = socket
+            self.address = address
+            self.buffer = buffer
+            self.lastcheck = lastcheck
+
+    # Used to store different types of occurences
+    _EVENT_NEW_PLAYER = 1
+    _EVENT_PLAYER_LEFT = 2
+    _EVENT_COMMAND = 3
+
+    # Different states we can be in while reading data from client
+    # See _process_sent_data function
+    _READ_STATE_NORMAL = 1
+    _READ_STATE_COMMAND = 2
+    _READ_STATE_SUBNEG = 3
+
+    # Command codes used by Telnet protocol
+    # See _process_sent_data function
+    _TN_INTERPRET_AS_COMMAND = 255
+    _TN_ARE_YOU_THERE = 246
+    _TN_WILL = 251
+    _TN_WONT = 252
+    _TN_DO = 253
+    _TN_DONT = 254
+    _TN_SUBNEGOTIATION_START = 250
+    _TN_SUBNEGOTIATION_END = 240
+
+    # socket used to listen for new clients
+    _listen_socket = None
+    # holds info on clients. Maps client id to _Client object
+    _clients = {}
+    # counter for assigning each client a new id
+    _nextid = 0
+    # list of occurences waiting to be handled by the code
+    _events = []
+    # list of newly-added occurences
+    _new_events = []
+
+    def __init__(self):
+        """Constructs the MudServer object and starts listening for
+        new players.
+        """
+
+        self._clients = {}
+        self._nextid = 0
+        self._events = []
+        self._new_events = []
+
+        # create a new tcp socket which will be used to listen for new clients
+        self._listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+        # set a special option on the socket which allows the port to be
+        # immediately without having to wait
+        self._listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
+                                       1)
+
+        # bind the socket to an ip address and port. Port 23 is the standard
+        # telnet port which telnet clients will use, however on some platforms
+        # this requires root permissions, so we use a higher arbitrary port
+        # number instead: 1234. Address 0.0.0.0 means that we will bind to all
+        # of the available network interfaces
+        self._listen_socket.bind(("0.0.0.0", 1234))
+
+        # set to non-blocking mode. This means that when we call 'accept', it
+        # will return immediately without waiting for a connection
+        self._listen_socket.setblocking(False)
+
+        # start listening for connections on the socket
+        self._listen_socket.listen(1)
+
+    def update(self):
+        """Checks for new players, disconnected players, and new
+        messages sent from players. This method must be called before
+        up-to-date info can be obtained from the 'get_new_players',
+        'get_disconnected_players' and 'get_commands' methods.
+        It should be called in a loop to keep the game running.
+        """
+
+        # check for new stuff
+        self._check_for_new_connections()
+        self._check_for_disconnected()
+        self._check_for_messages()
+
+        # move the new events into the main events list so that they can be
+        # obtained with 'get_new_players', 'get_disconnected_players' and
+        # 'get_commands'. The previous events are discarded
+        self._events = list(self._new_events)
+        self._new_events = []
+
+    def disconnect_player(self, clid):
+        cl = self._clients[clid]
+        cl.socket.close()
+        self._handle_disconnect(clid)
+
+    def get_new_players(self):
+        """Returns a list containing info on any new players that have
+        entered the game since the last call to 'update'. Each item in
+        the list is a player id number.
+        """
+        retval = []
+        # go through all the events in the main list
+        for ev in self._events:
+            # if the event is a new player occurence, add the info to the list
+            if ev[0] == self._EVENT_NEW_PLAYER:
+                retval.append(ev[1])
+        # return the info list
+        return retval
+
+    def get_disconnected_players(self):
+        """Returns a list containing info on any players that have left
+        the game since the last call to 'update'. Each item in the list
+        is a player id number.
+        """
+        retval = []
+        # go through all the events in the main list
+        for ev in self._events:
+            # if the event is a player disconnect occurence, add the info to
+            # the list
+            if ev[0] == self._EVENT_PLAYER_LEFT:
+                retval.append(ev[1])
+        # return the info list
+        return retval
+
+    def get_commands(self):
+        """Returns a list containing any commands sent from players
+        since the last call to 'update'. Each item in the list is a
+        3-tuple containing the id number of the sending player, a
+        string containing the command (i.e. the first word of what
+        they typed), and another string containing the text after the
+        command
+        """
+        retval = []
+        # go through all the events in the main list
+        for ev in self._events:
+            # if the event is a command occurence, add the info to the list
+            if ev[0] == self._EVENT_COMMAND:
+                retval.append((ev[1], ev[2], ev[3]))
+        # return the info list
+        return retval
+
+    def send_message(self, to, message, line_ending='\r\n'):
+        """Sends the text in the 'message' parameter to the player with
+        the id number given in the 'to' parameter. The text will be
+        printed out in the player's terminal.
+        """
+        # we make sure to put a newline on the end so the client receives the
+        # message on its own line
+        self._attempt_send(to, message + line_ending)
+
+    def shutdown(self):
+        """Closes down the server, disconnecting all clients and
+        closing the listen socket.
+        """
+        # for each client
+        for cl in self._clients.values():
+            # close the socket, disconnecting the client
+            cl.socket.shutdown()
+            cl.socket.close()
+        # stop listening for new clients
+        self._listen_socket.close()
+
+    def _attempt_send(self, clid, data):
+        # python 2/3 compatability fix - convert non-unicode string to unicode
+        if sys.version < '3' and type(data) != unicode:
+            data = unicode(data, "latin1")
+        try:
+            # look up the client in the client map and use 'sendall' to send
+            # the message string on the socket. 'sendall' ensures that all of
+            # the data is sent in one go
+            if sys.version_info != (3, 4, 0):
+                bytes_to_send = bytearray(data, 'latin1')
+            else:
+                bytes_to_send = bytearray(data)
+
+            client_socket = self._clients[clid].socket
+            client_socket.sendall(bytes_to_send)
+        # KeyError will be raised if there is no client with the given id in
+        # the map
+        except KeyError:
+            pass
+        # If there is a connection problem with the client (e.g. they have
+        # disconnected) a socket error will be raised
+        except Exception as e:
+            sys.print_exception(e)
+            self._handle_disconnect(clid)
+
+    def _check_for_new_connections(self):
+
+        # 'select' is used to check whether there is data waiting to be read
+        # from the socket. We pass in 3 lists of sockets, the first being those
+        # to check for readability. It returns 3 lists, the first being
+        # the sockets that are readable. The last parameter is how long to wait
+        # - we pass in 0 so that it returns immediately without waiting
+        rlist, wlist, xlist = select.select([self._listen_socket], [], [], 0)
+
+        # if the socket wasn't in the readable list, there's no data available,
+        # meaning no clients waiting to connect, and so we can exit the method
+        # here
+        if self._listen_socket not in rlist:
+            return
+
+        # 'accept' returns a new socket and address info which can be used to
+        # communicate with the new client
+        joined_socket, addr = self._listen_socket.accept()
+
+        # set non-blocking mode on the new socket. This means that 'send' and
+        # 'recv' will return immediately without waiting
+        joined_socket.setblocking(False)
+
+        # construct a new _Client object to hold info about the newly connected
+        # client. Use 'nextid' as the new client's id number
+        self._clients[self._nextid] = MudServer._Client(joined_socket, addr[0],
+                                                        "", time.time())
+
+        # add a new player occurence to the new events list with the player's
+        # id number
+        self._new_events.append((self._EVENT_NEW_PLAYER, self._nextid))
+
+        # add 1 to 'nextid' so that the next client to connect will get a
+        # unique id number
+        self._nextid += 1
+
+    def _check_for_disconnected(self):
+
+        # go through all the clients
+        for id, cl in list(self._clients.items()):
+
+            # if we last checked the client less than 5 seconds ago, skip this
+            # client and move on to the next one
+            if time.time() - cl.lastcheck < 5.0:
+                continue
+
+            # send the client an invisible character. It doesn't actually
+            # matter what we send, we're really just checking that data can
+            # still be written to the socket. If it can't, an error will be
+            # raised and we'll know that the client has disconnected.
+            self._attempt_send(id, "\x00")
+
+            # update the last check time
+            cl.lastcheck = time.time()
+
+    def _check_for_messages(self):
+
+        # go through all the clients
+        for id, cl in list(self._clients.items()):
+
+            # we use 'select' to test whether there is data waiting to be read
+            # from the client socket. The function takes 3 lists of sockets,
+            # the first being those to test for readability. It returns 3 list
+            # of sockets, the first being those that are actually readable.
+            rlist, wlist, xlist = select.select([cl.socket], [], [], 0)
+
+            # if the client socket wasn't in the readable list, there is no
+            # new data from the client - we can skip it and move on to the next
+            # one
+            if cl.socket not in rlist:
+                continue
+
+            try:
+                # read data from the socket, using a max length of 4096
+                data = cl.socket.recv(4096).decode("latin1")
+
+                # process the data, stripping out any special Telnet commands
+                message = self._process_sent_data(cl, data)
+
+                # if there was a message in the data
+                if message:
+
+                    # remove any spaces, tabs etc from the start and end of
+                    # the message
+                    message = message.strip()
+
+                    # separate the message into the command (the first word)
+                    # and its parameters (the rest of the message)
+                    command, params = (message.split(" ", 1) + ["", ""])[:2]
+
+                    # add a command occurence to the new events list with the
+                    # player's id number, the command and its parameters
+                    self._new_events.append((self._EVENT_COMMAND, id,
+                                             command.lower(), params))
+
+            # if there is a problem reading from the socket (e.g. the client
+            # has disconnected) a socket error will be raised
+            except socket.error:
+                self._handle_disconnect(id)
+
+    def _handle_disconnect(self, clid):
+
+        # remove the client from the clients map
+        del(self._clients[clid])
+
+        # add a 'player left' occurence to the new events list, with the
+        # player's id number
+        self._new_events.append((self._EVENT_PLAYER_LEFT, clid))
+
+    def _process_sent_data(self, client, data):
+
+        # the Telnet protocol allows special command codes to be inserted into
+        # messages. For our very simple server we don't need to response to
+        # any of these codes, but we must at least detect and skip over them
+        # so that we don't interpret them as text data.
+        # More info on the Telnet protocol can be found here:
+        # http://pcmicro.com/netfoss/telnet.html
+
+        # start with no message and in the normal state
+        message = None
+        state = self._READ_STATE_NORMAL
+
+        # go through the data a character at a time
+        for c in data:
+
+            # handle the character differently depending on the state we're in:
+
+            # normal state
+            if state == self._READ_STATE_NORMAL:
+
+                # if we received the special 'interpret as command' code,
+                # switch to 'command' state so that we handle the next
+                # character as a command code and not as regular text data
+                if ord(c) == self._TN_INTERPRET_AS_COMMAND:
+                    state = self._READ_STATE_COMMAND
+
+                # if we get a newline character, this is the end of the
+                # message. Set 'message' to the contents of the buffer and
+                # clear the buffer
+                elif c == "\n":
+                    message = client.buffer
+                    client.buffer = ""
+
+                # some telnet clients send the characters as soon as the user
+                # types them. So if we get a backspace character, this is where
+                # the user has deleted a character and we should delete the
+                # last character from the buffer.
+                elif c == "\x08":
+                    client.buffer = client.buffer[:-1]
+
+                # otherwise it's just a regular character - add it to the
+                # buffer where we're building up the received message
+                else:
+                    client.buffer += c
+
+            # command state
+            elif state == self._READ_STATE_COMMAND:
+
+                # the special 'start of subnegotiation' command code indicates
+                # that the following characters are a list of options until
+                # we're told otherwise. We switch into 'subnegotiation' state
+                # to handle this
+                if ord(c) == self._TN_SUBNEGOTIATION_START:
+                    state = self._READ_STATE_SUBNEG
+
+                # if the command code is one of the 'will', 'wont', 'do' or
+                # 'dont' commands, the following character will be an option
+                # code so we must remain in the 'command' state
+                elif ord(c) in (self._TN_WILL, self._TN_WONT, self._TN_DO,
+                                self._TN_DONT):
+                    state = self._READ_STATE_COMMAND
+
+                # for all other command codes, there is no accompanying data so
+                # we can return to 'normal' state.
+                else:
+                    state = self._READ_STATE_NORMAL
+
+            # subnegotiation state
+            elif state == self._READ_STATE_SUBNEG:
+
+                # if we reach an 'end of subnegotiation' command, this ends the
+                # list of options and we can return to 'normal' state.
+                # Otherwise we must remain in this state
+                if ord(c) == self._TN_SUBNEGOTIATION_END:
+                    state = self._READ_STATE_NORMAL
+
+        # return the contents of 'message' which is either a string or None
+        return message

+{"name": "test", "room": "Room001", "inventory": null, "prompt": "> "}
\ No newline at end of file

+
+# import datetime
+
+class BaseRoom(object):
+
+  def __init__(self, title, description, exits, look_items):
+    self.title = title
+    self.description = description
+    self.exits = exits
+    self.look_items = look_items
+    # self.created = datetime.datetime.now()
+
+  def get_title(self):
+    return self.title
+
+  def get_description(self):
+    return self.description
+
+  def get_exits(self):
+    return self.exits
+
+  def get_look_items(self):
+    return self.look_items

+from .baseroom import BaseRoom
+
+class Room001(BaseRoom):
+
+  def __init__(self):
+    
+    title = "Behind the bar"
+    description = "The back of the bar gives a full view of the tavern. The bar\r\n top is a large wooden plank thrown across some barrels."
+    exits = {"tavern": "Tavern"}
+    look_items = {
+      "bar": "The bar is a long wooden plank thrown over roughly hewn barrels.",
+      "barrel,barrels": "The old barrels bands are thick with oxidation and stained\r\n with the purple of spilled wine.",
+      "wooden,oak,plank": "An old solid oak plank that has a large number of chips\r\n and drink marks."
+    }
+
+    super(Room001, self).__init__(title, description, exits, look_items)

+from .baseroom import BaseRoom
+
+class Tavern(BaseRoom):
+
+  def __init__(self):
+    
+    title = "Tavern"
+    description = "You're in a cozy tavern warmed by an open fire."
+    exits = {"outside": "Outside", "behind bar": "Room001"}
+    look_items = {
+      "bar": "The bar is a long wooden plank thrown over roughly hewn barrels.",
+      "barrel,barrels": "The old barrels bands are thick with oxidation and stained\r\n with the purple of spilled wine.",
+      "wooden,oak,plank": "An old solid oak plank that has a large number of chips\r\n and drink marks.",
+      "fire": "The fire crackles quietly in the corner providing a small amount of light and heat."
+    }
+
+    super(Tavern, self).__init__(title, description, exits, look_items)

+#!/usr/bin/env python
+
+"""A simple Multi-User Dungeon (MUD) game. Players can talk to each
+other, examine their surroundings and move between rooms.
+
+Some ideas for things to try adding:
+    * More rooms to explore
+    * An 'emote' command e.g. 'emote laughs out loud' -> 'Mark laughs
+        out loud'
+    * A 'whisper' command for talking to individual players
+    * A 'shout' command for yelling to players in all rooms
+    * Items to look at in rooms e.g. 'look fireplace' -> 'You see a
+        roaring, glowing fire'
+    * Items to pick up e.g. 'take rock' -> 'You pick up the rock'
+    * Monsters to fight
+    * Loot to collect
+    * Saving players accounts between sessions
+    * A password login
+    * A shop from which to buy items
+
+author: Mark Frimston - mfrimston@gmail.com
+"""
+
+import time
+
+# import the MUD server class
+from mudserver import MudServer
+
+
+# structure defining the rooms in the game. Try adding more rooms to the game!
+rooms = {
+    "Tavern": {
+        "description": "You're in a cozy tavern warmed by an open fire.",
+        "exits": {"outside": "Outside"},
+    },
+    "Outside": {
+        "description": "You're standing outside a tavern. It's raining.",
+        "exits": {"inside": "Tavern"},
+    }
+}
+
+# stores the players in the game
+players = {}
+
+# start the server
+mud = MudServer()
+
+# main game loop. We loop forever (i.e. until the program is terminated)
+while True:
+
+    # pause for 1/5 of a second on each loop, so that we don't constantly
+    # use 100% CPU time
+    time.sleep(0.2)
+
+    # 'update' must be called in the loop to keep the game running and give
+    # us up-to-date information
+    mud.update()
+
+    # go through any newly connected players
+    for id in mud.get_new_players():
+
+        # add the new player to the dictionary, noting that they've not been
+        # named yet.
+        # The dictionary key is the player's id number. We set their room to
+        # None initially until they have entered a name
+        # Try adding more player stats - level, gold, inventory, etc
+        players[id] = {
+            "name": None,
+            "room": None,
+        }
+
+        # send the new player a prompt for their name
+        mud.send_message(id, "What is your name?")
+
+    # go through any recently disconnected players
+    for id in mud.get_disconnected_players():
+
+        # if for any reason the player isn't in the player map, skip them and
+        # move on to the next one
+        if id not in players:
+            continue
+
+        # go through all the players in the game
+        for pid, pl in players.items():
+            # send each player a message to tell them about the diconnected
+            # player
+            mud.send_message(pid, "{} quit the game".format(
+                                                        players[id]["name"]))
+
+        # remove the player's entry in the player dictionary
+        del(players[id])
+
+    # go through any new commands sent from players
+    for id, command, params in mud.get_commands():
+
+        # if for any reason the player isn't in the player map, skip them and
+        # move on to the next one
+        if id not in players:
+            continue
+
+        # if the player hasn't given their name yet, use this first command as
+        # their name and move them to the starting room.
+        if players[id]["name"] is None:
+
+            players[id]["name"] = command
+            players[id]["room"] = "Tavern"
+
+            # go through all the players in the game
+            for pid, pl in players.items():
+                # send each player a message to tell them about the new player
+                mud.send_message(pid, "{} entered the game".format(
+                                                        players[id]["name"]))
+
+            # send the new player a welcome message
+            mud.send_message(id, "Welcome to the game, {}. ".format(
+                                                           players[id]["name"])
+                             + "Type 'help' for a list of commands. Have fun!")
+
+            # send the new player the description of their current room
+            mud.send_message(id, rooms[players[id]["room"]]["description"])
+
+        # each of the possible commands is handled below. Try adding new
+        # commands to the game!
+
+        # 'help' command
+        elif command == "help":
+
+            # send the player back the list of possible commands
+            mud.send_message(id, "Commands:")
+            mud.send_message(id, "  say <message>  - Says something out loud, "
+                                 + "e.g. 'say Hello'")
+            mud.send_message(id, "  look           - Examines the "
+                                 + "surroundings, e.g. 'look'")
+            mud.send_message(id, "  go <exit>      - Moves through the exit "
+                                 + "specified, e.g. 'go outside'")
+
+        # 'say' command
+        elif command == "say":
+
+            # go through every player in the game
+            for pid, pl in players.items():
+                # if they're in the same room as the player
+                if players[pid]["room"] == players[id]["room"]:
+                    # send them a message telling them what the player said
+                    mud.send_message(pid, "{} says: {}".format(
+                                                players[id]["name"], params))
+
+        # 'look' command
+        elif command == "look":
+
+            # store the player's current room
+            rm = rooms[players[id]["room"]]
+
+            # send the player back the description of their current room
+            mud.send_message(id, rm["description"])
+
+            playershere = []
+            # go through every player in the game
+            for pid, pl in players.items():
+                # if they're in the same room as the player
+                if players[pid]["room"] == players[id]["room"]:
+                    # ... and they have a name to be shown
+                    if players[pid]["name"] is not None:
+                        # add their name to the list
+                        playershere.append(players[pid]["name"])
+
+            # send player a message containing the list of players in the room
+            mud.send_message(id, "Players here: {}".format(
+                                                    ", ".join(playershere)))
+
+            # send player a message containing the list of exits from this room
+            mud.send_message(id, "Exits are: {}".format(
+                                                    ", ".join(rm["exits"])))
+
+        # 'go' command
+        elif command == "go":
+
+            # store the exit name
+            ex = params.lower()
+
+            # store the player's current room
+            rm = rooms[players[id]["room"]]
+
+            # if the specified exit is found in the room's exits list
+            if ex in rm["exits"]:
+
+                # go through all the players in the game
+                for pid, pl in players.items():
+                    # if player is in the same room and isn't the player
+                    # sending the command
+                    if players[pid]["room"] == players[id]["room"] \
+                            and pid != id:
+                        # send them a message telling them that the player
+                        # left the room
+                        mud.send_message(pid, "{} left via exit '{}'".format(
+                                                      players[id]["name"], ex))
+
+                # update the player's current room to the one the exit leads to
+                players[id]["room"] = rm["exits"][ex]
+                rm = rooms[players[id]["room"]]
+
+                # go through all the players in the game
+                for pid, pl in players.items():
+                    # if player is in the same (new) room and isn't the player
+                    # sending the command
+                    if players[pid]["room"] == players[id]["room"] \
+                            and pid != id:
+                        # send them a message telling them that the player
+                        # entered the room
+                        mud.send_message(pid,
+                                         "{} arrived via exit '{}'".format(
+                                                      players[id]["name"], ex))
+
+                # send the player a message telling them where they are now
+                mud.send_message(id, "You arrive at '{}'".format(
+                                                          players[id]["room"]))
+
+            # the specified exit wasn't found in the current room
+            else:
+                # send back an 'unknown exit' message
+                mud.send_message(id, "Unknown exit '{}'".format(ex))
+
+        # some other, unrecognised command
+        else:
+            # send back an 'unknown command' message
+            mud.send_message(id, "Unknown command '{}'".format(command))

+{"test": "value"}
\ No newline at end of file