diff --git a/xpub-mud/README.md b/xpub-mud/README.md
new file mode 100644
index 0000000..f63c217
--- /dev/null
+++ b/xpub-mud/README.md
@@ -0,0 +1,154 @@
+MUD Pi
+======
+
+A simple text-based Multi-User Dungeon (MUD) game, which could be run on a
+Raspberry Pi or other low-end server.
+
+
+Requirements
+------------
+
+You will need to install _Python_ (2.7+ or 3.3+) where you wish to run the
+server. Installers for Windows and Mac can be found at
+. There are also tarballs for Linux, although
+the best way to install on Linux would be via the package manager.
+
+To allow players to connect remotely, the server will also need to be connected
+to the internet.
+
+To connect to the server you will need a telnet client. On Mac, Linux, and
+versions of Windows prior to Windows Vista, the telnet client is usually
+installed by default. For Windows Vista, 7, 8 or later, you may need to follow
+[this guide](http://technet.microsoft.com/en-us/library/cc771275%28v=ws.10%29.aspx)
+to install it.
+
+
+Running the Server
+------------------
+
+### On Windows
+
+Double click on `simplemud.py` - the file will be opened with the Python
+interpreter. To stop the server, simply close the terminal window.
+
+
+### On Mac OSX and Linux (including Raspberry Pi)
+
+From the terminal, change to the directory containing the script and run
+
+ python simplemud.py
+
+Note, if you are connected to the machine via SSH, you will find that the
+script stops running when you quit the SSH session. A simple way to leave the
+script running is to use a tool called `screen`. Connect via SSH as usual then
+run `screen`. You will enter what looks like a normal shell prompt, but now you
+can start the python script running and hit `ctl+a` followed by `d` to leave
+_screen_ running in the background. The next time you connect, you can
+re-attach to your screen session using `screen -r`. Alternatively you could
+[create a daemon script](http://jimmyg.org/blog/2010/python-daemon-init-script.html)
+to run the script in the background every time the server starts.
+
+
+Connecting to the Server
+------------------------
+
+If the server is running behind a NAT such as a home router, you will need to
+set up port **1234** to be forwarded to the machine running the server. See your
+router's instructions for how to set this up. There are a large number of
+setup guides for different models of router here:
+
+
+You will need to know the _external_ IP address of the machine running the
+server. This can be discovered by visiting from
+that machine.
+
+To connect to the server, open your operating system's terminal or command
+prompt and start the telnet client by running:
+
+ telnet 1234
+
+where `` is the external IP address of the server, as described
+above. 1234 is the port number that the server listens on.
+
+If you are using Windows Vista, 7, 8 or later and get the message:
+
+ 'telnet' is not recognized as an internal or external command, operable
+ program or batch file.
+
+then follow
+[this guide](http://technet.microsoft.com/en-us/library/cc771275%28v=ws.10%29.aspx)
+to install the Windows telnet client.
+
+If all goes well, you should be presented with the message
+
+ What is your name?
+
+To quit the telnet client, press `ctl + ]` to go to the prompt, and then
+type `quit`.
+
+
+What is Telnet?
+---------------
+
+Telnet is simple text-based network communication protocol that was invented in
+1969 and has since been superseded by other, more secure protocols. It does
+remain popular for a few specialised uses however, MUD games being one of these
+uses. A long (and boring) history of the telnet protocol can be found here:
+
+
+
+What is a MUD?
+--------------
+
+MUD is short for Multi-User Dungeon. A MUD is a text-based online role-playing
+game. MUDs were popular in the early 80s and were the precursor to the
+graphical Massively-Multiplayer Online Role-Playing Games we have today, like
+World of Warcraft. is a great site for learning
+more about MUDs.
+
+
+Extending the Game
+------------------
+
+MUD Pi is a free and open source project (that's _free_ as in _freedom_). This
+means that the source code is included and you are free to read it, copy it,
+extend it and use it as a starting point for your own MUD game or any other
+project. See `licence.md` for more info.
+
+MUD Pi was written in the Python programming language. If you have never used
+Python before, or are new to programming in general, why not try an online
+tutorial, such as .
+
+There are 2 source files in the project. `mudserver.py` is a module containing
+the `MudServer` class - a basic server script which handles player connections
+and sending and receiving messages. `simplemud.py` is an example game using
+`MudServer`, with player chat and rooms to move between.
+
+The best place to start tweaking the game would be to have a look at
+`simplemud.py`. Why not try adding more rooms to the game world? You'll find
+more ideas for things to try in the source code itself.
+
+Of course if you're feeling more adventurous you could take a look at the
+slightly more advanced networking code in `mudserver.py`.
+
+
+MUD-Pi-Based Projects
+---------------------
+
+Here are some of the cool projects people have made from MUD-Pi:
+
+* **[ESP8266 MUD](http://git.savsoul.com/barry/esp8266-Mud) by Barry Ruffner** -
+ a MUD that runs entirely within an ESP8266 microchip, using MicroPython
+* **[MuddySwamp](https://github.com/ufosc/MuddySwamp) by the University of**
+ **Florida Open Source Club** - a UF-themed MUD
+* **[Dumserver](https://github.com/wowpin/dumserver) by Bartek Radwanski** -
+ a feature-rich MUD engine
+
+
+Author
+------
+
+MUD Pi was written by Mark Frimston
+
+For feedback, please email or add a comment on the
+project's [Github page](http://github.com/frimkron/mud-pi)
diff --git a/xpub-mud/__pycache__/mudserver.cpython-39.pyc b/xpub-mud/__pycache__/mudserver.cpython-39.pyc
new file mode 100644
index 0000000..eb0e935
Binary files /dev/null and b/xpub-mud/__pycache__/mudserver.cpython-39.pyc differ
diff --git a/xpub-mud/licence.md b/xpub-mud/licence.md
new file mode 100644
index 0000000..615dce1
--- /dev/null
+++ b/xpub-mud/licence.md
@@ -0,0 +1,19 @@
+Copyright (C) 2013 Mark Frimston
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/xpub-mud/mudserver.py b/xpub-mud/mudserver.py
new file mode 100644
index 0000000..ba5077f
--- /dev/null
+++ b/xpub-mud/mudserver.py
@@ -0,0 +1,405 @@
+"""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 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):
+ """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+"\n\r")
+
+ 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(socket.SHUT_RDWR)
+ 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
+ self._clients[clid].socket.sendall(bytearray(data, "latin1"))
+ # 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 socket.error:
+ 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
diff --git a/xpub-mud/xpub_mud.py b/xpub-mud/xpub_mud.py
new file mode 100644
index 0000000..80d1e58
--- /dev/null
+++ b/xpub-mud/xpub_mud.py
@@ -0,0 +1,323 @@
+#!/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 = {
+ "studio": {
+ "description": "You're in the XPUB studio. Someone is making coffee in the back.",
+ "exits": {"south": "neutral zone"}
+ },
+ "office": {
+ "description": "You're in the office. Leslie is on the phone.",
+ "exits": {"north": "neutral zone"}
+ },
+ "neutral zone": {
+ "description": "You're in the neutral zone. Some stuff happens.",
+ "exits": {
+ "south": "office",
+ "north": "studio",
+ "west" : "artificial research station"
+ }
+ },
+ "artificial research station": {
+ "description": "You're in the artificial research station. What happens here?",
+ "exits": {"south": "neutral zone"}
+ }
+}
+
+# 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
+ # this is the room in which the game starts
+ players[id]["room"] = "studio"
+
+ # 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!\n")
+
+ # 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 - Says something out loud, "
+ + "e.g. 'say Hello'")
+ mud.send_message(id, " look - Examines the "
+ + "surroundings, e.g. 'look'")
+ mud.send_message(id, " go - Moves through the exit "
+ + "specified, e.g. 'go outside'")
+ mud.send_message(id, " create - Creates a new exit and room")
+ mud.send_message(id, " describe - Change the description of the current room")
+
+ # '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
+ current_room = rooms[players[id]["room"]]
+
+ # send the player back the description of their current room
+ mud.send_message(id, current_room["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
+ playershere_string = ", ".join(playershere)
+ mud.send_message(id, f"Players here: { playershere_string }")
+
+ # send player a message containing the list of exits from this room
+ exits = ", ".join(current_room["exits"])
+ mud.send_message(id, f"Exits are: { exits }")
+
+ # 'go' command
+ elif command == "go":
+
+ # store the exit name
+ ex = params.lower()
+
+ # store the player's current room
+ current_room = rooms[players[id]["room"]]
+
+ # if the specified exit is found in the room's exits list
+ if ex in current_room["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"] = current_room["exits"][ex]
+ current_room = 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))
+
+ # 'create' command
+ elif command == "create":
+
+ # store the exit or room that will be created
+ parameters = params.lower()
+ parameters_list = parameters.split()
+ print("[INSPECT] parameters: ", parameters_list)
+
+ if len(parameters_list) >= 1:
+ # store the new exit name
+ new_exit = parameters_list[0]
+ print("[INSPECT] new exit: ", new_exit)
+ else:
+ new_exit = None
+
+ if len(parameters_list) >= 2:
+ # store the new room name
+ new_room = " ".join(parameters_list[1:])
+ print("[INSPECT] new room: ", new_room)
+ else:
+ new_exit = None
+
+ # store the player's current room
+ current_room = players[id]["room"]
+ print("[INSPECT] current room: ", current_room)
+
+ # store information about the player's current room
+ current_room_dict = rooms[players[id]["room"]]
+ print("[INSPECT] current room dict: ", current_room_dict)
+
+ # if both the new exit and new room are given
+ if new_exit is not None and new_room is not None:
+
+ # send player a message when the exit already exists
+ if new_exit in current_room_dict["exits"]:
+ mud.send_message(id, "This exit already exist.")
+ exits = ", ".join(current_room["exits"])
+
+ # create new room
+ else:
+ print(f"[INSPECT] Make new room: { new_room }, in the direction: { new_exit }")
+
+ # add the new exit to the current room
+ rooms[current_room]["exits"][new_exit] = new_room
+
+ # store information about the new room
+ rooms[new_room] = {}
+ rooms[new_room]["description"] = ""
+ rooms[new_room]["exits"] = {}
+
+ # add the opposite exit direction to the exits of the new room
+ if new_exit == "west":
+ exit_to_add = "east"
+ elif new_exit == "east":
+ exit_to_add = "east"
+ if new_exit == "north":
+ exit_to_add = "south"
+ elif new_exit == "south":
+ exit_to_add = "north"
+
+ # store this exit to the new room
+ rooms[new_room]["exits"][exit_to_add] = current_room
+
+ # announce the new room to the player
+ mud.send_message(id, f"A new room is added: { new_room } (in the { new_exit })")
+ # invite the player to write a description for the room
+ mud.send_message(id, "The room is not described yet. When you are in the room, you can use 'describe' to add a description. For example: 'describe This is the XML! It smells a bit muffy here.'")
+
+ # warn the player when the "create" command is not used in the right way
+ else:
+ mud.send_message(id, f"Sorry you cannot create a new room in that way. Try: 'create direction roomname'")
+
+ # 'describe' command
+ elif command == "describe":
+
+ # store the exit or room that will be created
+ description = params.lower()
+ print("[INSPECT] description: ", description)
+
+ # store the player's current room
+ current_room = players[id]["room"]
+ print("[INSPECT] current room: ", current_room)
+
+ rooms[new_room]["description"] = description
+
+ # some other, unrecognised command
+ else:
+ # send back an 'unknown command' message
+ mud.send_message(id, "Unknown command '{}'".format(command))