Initial Commit

LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org>

README.md

@@ -0,0 +1,73 @@
+# FunMOW
+A multiplayer text based game written in Go, with MU* inspired userspace. Being MU* inspired, FunMOW has support for expanding the world with a set of in-game commands.
+
+## Installing
+
+	go get github.com/naleek/funmow/...
+	
+## Running
+	funmow
+
+## Connecting
+To fully enjoy FunMOW, use a MU* client. In testing (MacOS), the bog standard `telnet` command doesn't support unicode, but netcat (`nc`) does.
+
+## Issues
+
+* No configuration options with modifying source
+* Authentication and encryption are non-existent
+* Database access is abusive, in anticipation of switching to an in-memory based database, with disk persistence
+* Failure modes are ~~often~~ not reported to the player
+
+
+## Commands
+
+### Documentation Conventions
+`{command,alternate}`
+
+`[optional parameter]`
+
+`<required parameter>`
+
+### Database References
+All objects in the game have a database reference (dbref), which is a signed integer assigned when the object is created. Dbrefs are incremented sequentially.
+
+### Object References
+
+Object references support partial matches, if you see a frog and type `get f`, you will acquire the frog. An object can be referred to by dbref by using the number preceeded by am octothorpe. This is handy when you end up with two objects with the same name, and only want to get one of them: `get #123`
+
+## Login Commands
+These commands are only valid in the authentication phase of gameplay.
+
+	{con,connect} <username> <password>
+	quit
+
+## Basic Commands
+
+This is the stuff that you use the most when you're not building things.
+
+	{look,l} [object reference]
+	{examine,ex} <object reference>
+	{say,"} <something>
+	{pose,:} <action>
+	{inventory,i}
+	get <object reference>
+	drop <object reference>
+	enter <object reference>
+	leave
+	quit
+	
+
+### Building Commands
+
+A note on exits. Exits support fixed aliases, so that you have the freedom to assign hidden shortcuts to exits. For example, `<K>itchen;k;kitchen` will display as `<K>itchen`, but can be used as `<K>itchen` or `k` or `kitchen`. You can use as many aliases as you want on an exit.
+
+	@create <name>
+	@dig <name>[=<in exit>[,<out exit]]
+	@open <in exit>=<dbref>[,<out exit>]
+	@desc <object reference>=<description>
+	@name <object reference>=<name>
+	@tel <dbref>
+	@dump <object reference>
+	
+# Credits
+FunMOW was created and is maintained by Keelan Lightfoot.

client.go

@@ -0,0 +1,821 @@
+package funmow
+
+import (
+	"bufio"
+	"fmt"
+	"log"
+	"net"
+	"strings"
+	"unicode"
+)
+
+type Client struct {
+	conn             net.Conn
+	connectionID     int
+	player           Object
+	authenticated    bool
+	connected        bool
+	reader           *bufio.Reader
+	commandChan      chan string
+	inbound          chan PlayerEvent
+	outbound         EventChanSet
+	eventDistributor *EventDistributor
+	world            *Store
+}
+
+func NewClient(conn net.Conn, connectionID int, e *EventDistributor, w *Store) *Client {
+	c := new(Client)
+	c.conn = conn
+	c.connectionID = connectionID
+	c.reader = bufio.NewReader(conn)
+	c.authenticated = false
+	c.connected = true
+	c.commandChan = make(chan string)
+	c.inbound = make(chan PlayerEvent)
+	c.eventDistributor = e
+	c.world = w
+	return c
+}
+
+func (c *Client) Run() {
+
+	log.Print("Received connection from ", c.conn.RemoteAddr())
+
+	go func() {
+		for c.connected {
+			message, err := c.reader.ReadString('\n')
+			if err != nil {
+				c.connected = false
+				return
+			}
+			message = strings.TrimSpace(message)
+			if len(message) > 0 {
+				c.commandChan <- message
+			}
+		}
+	}()
+
+	c.splash()
+
+	for c.connected {
+		select {
+		case m := <-c.inbound:
+
+			switch m.messageType {
+			case EventTypeEmit:
+				fallthrough
+			case EventTypeOEmit:
+				if m.audience == c.player.Inside {
+					c.write("%s\n", m.message)
+				}
+			case EventTypePEmit:
+				c.write("%s\n", m.message)
+			case EventTypeWall:
+				speaker, found := c.world.Fetch(m.src)
+				if !found {
+					break
+				}
+				c.write("In the distance, you hear %s bellow out \"%s\"\n", speaker.Name, m.message)
+			case EventTypePage:
+				speaker, found := c.world.Fetch(m.src)
+				if !found {
+					break
+				}
+				c.write("%s pages you: \"%s\"\n", speaker.Name, m.message)
+			case EventTypeSay:
+				if m.audience == c.player.Inside {
+					if m.src == c.player.ID {
+						c.write("You say \"%s\"\n", m.message)
+					} else {
+						speaker, found := c.world.Fetch(m.src)
+						if !found {
+							break
+						}
+						c.write("%s says \"%s\"\n", speaker.Name, m.message)
+					}
+				}
+			case EventTypePose:
+				if m.audience == c.player.Inside {
+					if m.src == c.player.ID {
+						c.write("%s %s\n", c.player.Name, m.message)
+					} else {
+						speaker, found := c.world.Fetch(m.src)
+						if !found {
+							break
+						}
+						c.write("%s %s\n", speaker.Name, m.message)
+					}
+				}
+			}
+		case cmd := <-c.commandChan:
+			if c.authenticated {
+				c.handlePlayPhase(cmd)
+			} else {
+				c.handleLoginPhase(cmd)
+			}
+		}
+	}
+	if c.authenticated {
+		c.outbound.shutdownChan <- c.connectionID
+	}
+	c.conn.Close()
+
+	log.Print("Lost connection from ", c.conn.RemoteAddr())
+
+}
+
+func (c *Client) splash() {
+
+	c.write("Welcome to...\n")
+	c.write("  ___                __  __    ___  __      __\n")
+	c.write(" | __| _  _   _ _   |  \\/  |  / _ \\ \\ \\    / /\n")
+	c.write(" | _| | || | | ' \\  | |\\/| | | (_) | \\ \\/\\/ /\n")
+	c.write(" |_|   \\_,_| |_||_| |_|  |_|  \\___/   \\_/\\_/\n\n")
+	c.write("use connect <username> <password> to login.\n")
+
+}
+
+func (c *Client) handleLoginPhase(message string) {
+
+	fields := strings.FieldsFunc(message, func(c rune) bool {
+		return unicode.IsSpace(c)
+	})
+	switch fields[0] {
+	case "help":
+		c.write("Commands:\n\tcon[nect] <username>\n\tquit\n")
+	case "con":
+		fallthrough
+	case "connect":
+		if len(fields) == 3 {
+			pID, err := c.world.GetPlayerID(fields[1])
+			if err != nil {
+				c.write("Bad username or password.\n")
+				break
+			}
+			player, found := c.world.Fetch(pID)
+			if !found {
+				c.write("You appear to be having an existential crisis.\n")
+				c.connected = false
+				break
+			}
+
+			c.authenticated = true
+			c.player = player
+
+			// when a player authenticates, the ipc channels get turned on
+			subReq := EventSubscribeRequest{
+				connectionID: c.connectionID,
+				playerID:     c.player.ID,
+				inbound:      c.inbound,
+				chanSet:      make(chan EventChanSet),
+			}
+
+			c.outbound = c.eventDistributor.Subscribe(subReq)
+
+			c.write("Welcome back, %s!\n", fields[1])
+
+			c.lookCmd("")
+
+		} else {
+			c.write("What?\n")
+		}
+	case "quit":
+		c.quitCmd()
+	default:
+		c.write("What?\n")
+	}
+
+}
+
+func (c *Client) handlePlayPhase(message string) {
+
+	switch {
+	case message == "l":
+		c.lookCmd("")
+	case message == "look":
+		c.lookCmd("")
+	case strings.HasPrefix(message, "l "): // look at
+		c.lookCmd(strings.TrimPrefix(message, "l "))
+	case strings.HasPrefix(message, "look "): // look at
+		c.lookCmd(strings.TrimPrefix(message, "look "))
+	case strings.HasPrefix(message, "ex "):
+		c.examineCmd(strings.TrimPrefix(message, "ex "))
+	case strings.HasPrefix(message, "examine "):
+		c.examineCmd(strings.TrimPrefix(message, "examine "))
+	case strings.HasPrefix(message, "\""):
+		c.sayCmd(strings.TrimPrefix(message, "\""))
+	case strings.HasPrefix(message, "say "):
+		c.sayCmd(strings.TrimPrefix(message, "say "))
+	case strings.HasPrefix(message, ":"):
+		c.poseCmd(strings.TrimPrefix(message, ":"))
+	case strings.HasPrefix(message, "pose "):
+		c.poseCmd(strings.TrimPrefix(message, "pose "))
+	case message == "i":
+		c.inventoryCmd()
+	case message == "inventory":
+		c.inventoryCmd()
+	case strings.HasPrefix(message, "get "):
+		c.getCmd(strings.TrimPrefix(message, "get "))
+	case strings.HasPrefix(message, "drop "):
+		c.dropCmd(strings.TrimPrefix(message, "drop "))
+	case strings.HasPrefix(message, "enter "):
+		c.enterCmd(strings.TrimPrefix(message, "enter "))
+	case message == "leave":
+		c.leaveCmd()
+	case message == "quit":
+		c.quitCmd()
+	case message == "WHO":
+		c.whoCmd()
+	case strings.HasPrefix(message, "@create "):
+		c.createCmd(strings.TrimPrefix(message, "@create "))
+	case strings.HasPrefix(message, "@dig "):
+		c.digCmd(strings.TrimPrefix(message, "@dig "))
+	case strings.HasPrefix(message, "@open "):
+		c.openCmd(strings.TrimPrefix(message, "@open "))
+	case strings.HasPrefix(message, "@name "):
+		c.nameCmd(strings.TrimPrefix(message, "@name "))
+	case strings.HasPrefix(message, "@desc "):
+		c.descCmd(strings.TrimPrefix(message, "@desc "))
+	case strings.HasPrefix(message, "@tel "):
+		c.telCmd(strings.TrimPrefix(message, "@tel "))
+	case strings.HasPrefix(message, "@dump "):
+		c.dumpCmd(strings.TrimPrefix(message, "@dump "))
+	default:
+		if !c.goCmd(message) {
+			c.write("What?\n")
+		}
+	}
+
+}
+
+func (c *Client) lookCmd(at string) {
+
+	room, found := c.world.Fetch(c.player.Inside)
+	if !found {
+		c.write("Limbo\nThere's nothing to see here.\n")
+		return
+	}
+
+	if len(at) > 0 {
+		object, matchType := room.MatchLinkNames(at, c.player.ID, false).ExactlyOne()
+		switch matchType {
+		case MatchOne:
+			c.write("%s\n%s\n", object.DetailedName(), object.Description)
+		case MatchNone:
+			c.write("I don't see that here.\n")
+		case MatchMany:
+			c.write("I don't now which one you're trying to look at.\n")
+		}
+	} else {
+		c.write("%s\n%s\n", room.DetailedName(), room.Description)
+		c.lookLinks("thing", "Things:")
+		c.lookLinks("player", "Players:")
+		exits := room.GetLinkNames("exit", nil)
+		if len(exits) > 0 {
+			c.write("Exits:\n")
+			for _, e := range exits {
+				aliases := strings.Split(e, ";")
+				c.write("%s ", aliases[0])
+			}
+			c.write("\n")
+		}
+	}
+
+}
+
+func (c *Client) examineCmd(at string) {
+
+	room, found := c.world.Fetch(c.player.Inside)
+	if !found {
+		return
+	}
+
+	object, matchType := room.MatchLinkNames(at, c.player.ID, false).ExactlyOne()
+
+	switch matchType {
+	case MatchOne:
+		c.write("%s\n", object.DetailedName())
+		c.write("ID: %d\n", object.ID)
+		c.write("Type: %s\n", object.Type)
+		c.write("@name: %s\n", object.Name)
+		c.write("@desc: %s\n", object.Description)
+		c.write("Inside: %s\n", c.world.GetName(object.Inside))
+		c.write("Next: %s\n", c.world.GetName(object.Next))
+		c.write("Owner: %s\n", c.world.GetName(object.Owner))
+
+		inventory := object.GetLinkNames("*", nil)
+		if len(inventory) > 0 {
+			c.write("Contents:\n %s\n", strings.Join(inventory, "\n "))
+		}
+	case MatchNone:
+		c.write("I don't see that here.\n")
+	case MatchMany:
+		c.write("I don't know which one you're trying to examine.\n")
+	}
+
+}
+
+func (c *Client) lookLinks(linkType string, pretty string) {
+
+	room, found := c.world.Fetch(c.player.Inside)
+	if !found {
+		return
+	}
+
+	linknames := room.GetLinkNames(linkType, DBRefList{c.player.ID})
+
+	if len(linknames) > 0 {
+		c.write("%s\n %s\n", pretty, strings.Join(linknames, "\n "))
+	}
+
+}
+
+func (c *Client) sayCmd(message string) {
+
+	c.outbound.messageChan <- PlayerEvent{audience: c.player.Inside, src: c.player.ID, message: message, messageType: EventTypeSay}
+
+}
+
+func (c *Client) poseCmd(message string) {
+
+	c.outbound.messageChan <- PlayerEvent{audience: c.player.Inside, src: c.player.ID, dst: c.player.ID, message: message, messageType: EventTypePose}
+
+}
+
+func (c *Client) inventoryCmd() {
+
+	inventory := c.player.GetLinkNames("*", nil)
+
+	if len(inventory) > 0 {
+		c.write("Inventory:\n %s\n", strings.Join(inventory, "\n "))
+	} else {
+		c.write("You're not carrying anything.\n")
+	}
+
+}
+
+func (c *Client) getCmd(message string) {
+
+	room, found := c.world.Fetch(c.player.Inside)
+	if !found {
+		return
+	}
+
+	object, matchType := room.MatchLinkNames(message, c.player.ID, true).ExactlyOne()
+
+	switch matchType {
+	case MatchOne:
+		err := c.player.Contains(&object)
+		if err != nil {
+			return
+		}
+		c.player.Refresh()
+		c.write("You pick up %s.\n", object.Name)
+		c.oemit(room.ID, "%s picks up %s.", c.player.Name, object.Name)
+	case MatchNone:
+		c.write("I don't see that here.\n")
+	case MatchMany:
+		c.write("I don't know which one.\n")
+	}
+
+}
+
+func (c *Client) dropCmd(message string) {
+
+	room, found := c.world.Fetch(c.player.Inside)
+	if !found {
+		return
+	}
+
+	object, matchType := c.player.MatchLinkNames(message, c.player.ID, false).ExactlyOne()
+
+	switch matchType {
+	case MatchOne:
+		err := room.Contains(&object)
+		if err != nil {
+			return
+		}
+		c.player.Refresh()
+		c.write("You drop %s.\n", object.Name)
+		c.oemit(c.player.Inside, "%s drops %s.", c.player.Name, object.Name)
+	case MatchNone:
+		c.write("You're not carrying that.\n")
+	case MatchMany:
+		c.write("I don't now which one.\n")
+	}
+
+}
+
+func (c *Client) enterCmd(message string) {
+
+	room, found := c.world.Fetch(c.player.Inside)
+	if !found {
+		return
+	}
+
+	object, matchType := room.MatchLinkNames(message, c.player.ID, true).ExactlyOne()
+
+	switch matchType {
+	case MatchOne:
+		err := object.Contains(&c.player)
+		if err != nil {
+			return
+		}
+		c.player.Refresh()
+		c.write("You climb into %s.\n", object.Name)
+		c.oemit(room.ID, "%s climbs into %s.", c.player.Name, object.Name)
+		c.oemit(object.ID, "%s squeezes into %s with you.", c.player.Name, object.Name)
+	case MatchNone:
+		c.write("I don't see that here.\n")
+	case MatchMany:
+		c.write("I don't now which one.\n")
+	}
+}
+
+func (c *Client) leaveCmd() {
+
+	object, found := c.world.Fetch(c.player.Inside)
+	if !found {
+		return
+	}
+
+	if object.Inside == 0 { // probably trying to 'leave' a room
+		c.write("You can't leave here.\n")
+		return
+	}
+
+	room, found := c.world.Fetch(object.Inside)
+	if !found {
+		return
+	}
+
+	err := room.Contains(&c.player)
+	if err != nil {
+		return
+	}
+
+	c.player.Refresh()
+
+	c.write("You climb out of %s.\n", object.Name)
+	c.oemit(object.ID, "%s climbs out of %s.", c.player.Name, object.Name)
+	c.oemit(room.ID, "%s climbs out of %s.", c.player.Name, object.Name)
+
+}
+
+func (c *Client) quitCmd() {
+
+	c.write("So long, it's been good to know yah.\n")
+	c.connected = false
+
+}
+
+func (c *Client) whoCmd() {
+	onlinePlayers := c.eventDistributor.OnlinePlayers()
+
+	c.write("Currently Online:\n")
+
+	for _, ref := range onlinePlayers {
+		c.write("%s\n", c.world.GetName(ref))
+	}
+}
+
+func (c *Client) createCmd(message string) {
+
+	room, found := c.world.Fetch(c.player.Inside)
+	if !found {
+		return
+	}
+
+	o, _ := c.world.Allocate("thing")
+	o.Name = strings.TrimSpace(message)
+	o.Owner = c.player.ID
+	o.Commit()
+
+	err := room.Contains(&o)
+	if err != nil {
+		return
+	}
+
+	c.emit(room.ID, "A %s appears out of the ether.", o.Name)
+	c.write("%s Created.\n", o.DetailedName())
+
+}
+
+func (c *Client) openCmd(message string) {
+	// @open <in1;in2;in3;etc>=#<room>,<out1;out2;out3;etc>
+
+	slicey := strings.SplitN(message, "=", 2)
+
+	if len(slicey) < 2 {
+		c.write("Bad command or file name.\n")
+		return
+	}
+
+	srcExitSpec := strings.TrimSpace(slicey[0])
+
+	stuff := strings.Split(slicey[1], ",")
+	if len(stuff) > 2 {
+		c.write("Bad command or file name.\n")
+		return
+	}
+
+	makeReturnExit := false
+	var returnExitSpec string
+	if len(stuff) == 2 {
+		makeReturnExit = true
+		returnExitSpec = stuff[1]
+	}
+
+	target, err := NewDBRefFromHashRef(stuff[0])
+	if err != nil {
+		c.write("Bad target DBRef.\n")
+		return
+	}
+
+	room, found := c.world.Fetch(c.player.Inside)
+	if !found {
+		return
+	}
+
+	targetRoom, found := c.world.Fetch(target)
+	if !found {
+		c.write("Target not found.\n")
+		return
+	}
+
+	toExit, _ := c.world.Allocate("exit")
+	toExit.Name = srcExitSpec
+	toExit.Next = targetRoom.ID
+	toExit.Owner = c.player.ID
+	toExit.Commit()
+
+	err = room.Contains(&toExit)
+	if err != nil {
+		return
+	}
+
+	c.write("%s Created.\n", toExit.DetailedName())
+
+	if makeReturnExit {
+		fromExit, _ := c.world.Allocate("exit")
+		fromExit.Name = returnExitSpec
+		fromExit.Next = room.ID
+		fromExit.Owner = c.player.ID
+		fromExit.Commit()
+
+		err = targetRoom.Contains(&fromExit)
+		if err != nil {
+			return
+		}
+
+		c.write("%s Created.\n", fromExit.DetailedName())
+	}
+
+}
+
+func (c *Client) digCmd(message string) {
+	// @dig <Room name>=<in1;in2;in3;etc>,<out1;out2;out3;etc>
+	//@dig foo=<F>oo;foo;f,<B>ack;back;b
+	slicey := strings.SplitN(message, "=", 2)
+
+	if len(slicey) < 1 {
+		c.write("Rooms can't not have names.\n")
+		return
+	}
+
+	roomName := strings.TrimSpace(slicey[0])
+
+	exits := make([]string, 0)
+
+	if len(slicey) == 2 {
+		exitSpec := strings.TrimSpace(slicey[1])
+		exits = strings.Split(exitSpec, ",")
+		if len(exits) > 2 {
+			c.write("You've listed more than two exits. That doesn't even make sense.\n")
+			return
+		}
+	}
+
+	newRoom, _ := c.world.Allocate("room")
+	newRoom.Name = roomName
+	newRoom.Owner = c.player.ID
+	newRoom.Commit()
+
+	c.write("%s Created.\n", newRoom.DetailedName())
+
+	if len(exits) > 0 {
+		room, found := c.world.Fetch(c.player.Inside)
+		if !found {
+			return
+		}
+		toExit, _ := c.world.Allocate("exit")
+		toExit.Name = exits[0]
+		toExit.Next = newRoom.ID
+		toExit.Owner = c.player.ID
+		toExit.Commit()
+
+		err := room.Contains(&toExit)
+		if err != nil {
+			return
+		}
+
+		c.write("%s Created.\n", toExit.DetailedName())
+
+		if len(exits) == 2 {
+			fromExit, _ := c.world.Allocate("exit")
+			fromExit.Name = exits[1]
+			fromExit.Next = room.ID
+			fromExit.Owner = c.player.ID
+			fromExit.Commit()
+
+			err = newRoom.Contains(&fromExit)
+			if err != nil {
+				return
+			}
+
+			c.write("%s Created.\n", fromExit.DetailedName())
+
+		}
+	}
+
+}
+
+func (c *Client) nameCmd(message string) {
+	room, found := c.world.Fetch(c.player.Inside)
+	if !found {
+		return
+	}
+
+	slicey := strings.SplitN(message, "=", 2)
+
+	if len(slicey) == 1 {
+		c.write("Things can't not have names.\n")
+		return
+	}
+
+	objectName := strings.TrimSpace(slicey[0])
+	name := strings.TrimSpace(slicey[1])
+
+	candidate, matchType := room.MatchLinkNames(objectName, c.player.ID, false).ExactlyOne()
+	switch matchType {
+	case MatchOne:
+		candidate.Name = name
+		candidate.Commit()
+		c.write("Name set.\n")
+		c.player.Refresh()
+	case MatchNone:
+		c.write("I don't see that here.\n")
+	case MatchMany:
+		c.write("I don't now which one.\n")
+	}
+
+}
+func (c *Client) descCmd(message string) {
+
+	room, found := c.world.Fetch(c.player.Inside)
+	if !found {
+		return
+	}
+
+	slicey := strings.SplitN(message, "=", 2)
+
+	objectName := strings.TrimSpace(slicey[0])
+	description := ""
+	if len(slicey) > 1 {
+		description = strings.TrimSpace(slicey[1])
+	}
+
+	var editObject *Object
+	switch objectName {
+	case "here":
+		editObject = &room
+	case "me":
+		editObject = &c.player
+	default:
+		candidate, matchType := room.MatchLinkNames(objectName, c.player.ID, false).ExactlyOne()
+		switch matchType {
+		case MatchOne:
+			editObject = &candidate
+		case MatchNone:
+			c.write("I don't see that here.\n")
+			return
+		case MatchMany:
+			c.write("I don't now which one.\n")
+			return
+		}
+	}
+
+	editObject.Description = description
+	editObject.Commit()
+	c.player.Refresh()
+	c.write("Description set.\n")
+
+}
+
+func (c *Client) telCmd(destStr string) {
+
+	dest, err := NewDBRefFromHashRef(destStr)
+
+	if err != nil {
+		c.write("That doesn't look like a DBRef.\n")
+		return
+	}
+
+	newRoom, found := c.world.Fetch(dest)
+	if !found {
+		c.write("That doesn't exist.\n")
+		return
+	}
+
+	c.write("You feel an intense wooshing sensation.\n")
+	err = newRoom.Contains(&c.player)
+	if err != nil {
+		return
+	}
+
+	c.player.Refresh()
+	c.lookCmd("")
+
+}
+
+func (c *Client) dumpCmd(refStr string) {
+
+	ref, err := NewDBRefFromHashRef(refStr)
+
+	if err != nil {
+		c.write("That doesn't look like a DBRef.\n")
+		return
+	}
+
+	obj, found := c.world.Fetch(ref)
+	if !found {
+		c.write("That doesn't exist.\n")
+		return
+	}
+
+	c.write("%s\n", c.world.DumpObject(obj.ID))
+
+}
+
+func (c *Client) goCmd(dir string) bool {
+
+	room, found := c.world.Fetch(c.player.Inside)
+	if !found {
+		return false
+	}
+
+	exit, matchType := room.MatchExitNames(dir).ExactlyOne()
+	switch matchType {
+	case MatchOne:
+		if exit.Next.Valid() {
+			newRoom, found := c.world.Fetch(exit.Next)
+			if !found {
+				return false
+			}
+			err := newRoom.Contains(&c.player)
+			if err != nil {
+				return false
+			}
+			c.player.Refresh()
+			c.write("You head towards %s.\n", newRoom.Name)
+			c.oemit(room.ID, "%s leaves the room.", c.player.Name)
+			c.oemit(newRoom.ID, "%s enters the room.", c.player.Name)
+			return true
+		}
+	case MatchNone:
+		return false
+	case MatchMany:
+		c.write("Ambiguous exit names are ambiguous.\n")
+		return true
+	}
+
+	return false
+
+}
+
+func (c *Client) oemit(audience DBRef, format string, a ...interface{}) {
+
+	message := fmt.Sprintf(format, a...)
+	c.outbound.messageChan <- PlayerEvent{audience: audience, src: c.player.ID, dst: c.player.ID, message: message, messageType: EventTypeOEmit}
+
+}
+
+func (c *Client) write(format string, a ...interface{}) {
+
+	fmt.Fprintf(c.conn, format, a...)
+
+}
+
+func (c *Client) pemit(audience DBRef, format string, a ...interface{}) {
+
+	message := fmt.Sprintf(format, a...)
+	c.outbound.messageChan <- PlayerEvent{audience: audience, src: c.player.ID, dst: c.player.ID, message: message, messageType: EventTypePEmit}
+
+}
+
+func (c *Client) emit(audience DBRef, format string, a ...interface{}) {
+
+	message := fmt.Sprintf(format, a...)
+	c.outbound.messageChan <- PlayerEvent{audience: audience, src: c.player.ID, dst: c.player.ID, message: message, messageType: EventTypeEmit}
+
+}

cmd/funmow/main.go

@@ -0,0 +1,123 @@
+package main
+
+import (
+	"github.com/naleek/funmow"
+	"log"
+	"net"
+)
+
+const (
+	FunMOWVersion = "0.1"
+	FunMOWDefaultDB = "my.db"
+	FunMOWListen = ":4201"
+)
+
+func main() {
+
+	log.Print("Starting FunMOW Version ", FunMOWVersion)
+
+	log.Print("Using database ", FunMOWDefaultDB)
+	world := funmow.NewDB(FunMOWDefaultDB)
+	world.Open()
+
+	defer world.Close()
+
+	//seedDB(world)
+
+	log.Print("Listening for connections on ", FunMOWListen)
+	ln, err := net.Listen("tcp", FunMOWListen)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	log.Print("Starting event distributor...")
+
+	e := funmow.NewEventDistributor()
+	go e.Run()
+
+	log.Print("Waiting for connections...")
+	
+	sessionCounter := 0
+	for {
+		conn, _ := ln.Accept()
+		c := funmow.NewClient(conn, sessionCounter, e, world)
+		sessionCounter++
+		go c.Run()
+	}
+}
+
+func seedDB(world *funmow.Store) {
+	outside, _ := world.Allocate("room")
+	outside.Name = "outside"
+	outside.Description = "The great outdoors. It's scary out here."
+	outside.Commit()
+
+	ketamine, _ := world.Allocate("thing")
+	ketamine.Name = "ketamine"
+	ketamine.Description = "You see a small pill bottle containing roughly 20 ketamine."
+	ketamine.Commit()
+	outside.Contains(&ketamine)
+
+	yacht, _ := world.Allocate("thing")
+	yacht.Name = "gravy yacht"
+	yacht.Description = "A gravy yacht. Like a boat but bigger. Duh."
+	yacht.Commit()
+	outside.Contains(&yacht)
+
+	kitchen, _ := world.Allocate("room")
+	kitchen.Name = "kitchen"
+	kitchen.Description = "a lovely kitchen"
+	kitchen.Commit()
+
+	kettle, _ := world.Allocate("thing")
+	kettle.Name = "kettle"
+	kettle.Description = "a lovely little kettle"
+	kettle.Commit()
+	kitchen.Contains(&kettle)
+
+	bathroom, _ := world.Allocate("room")
+	bathroom.Name = "bathroom"
+	bathroom.Description = "a dirty bathroom"
+	bathroom.Commit()
+
+	toilet, _ := world.Allocate("thing")
+	toilet.Name = "toilet"
+	toilet.Description = "a nasty toilet"
+	toilet.Commit()
+	bathroom.Contains(&toilet)
+
+	door1, _ := world.Allocate("exit")
+	door1.Name = "<B>athroom;b;bathroom"
+	door1.Description = "a door"
+	door1.Next = bathroom.ID
+	door1.Commit()
+
+	door2, _ := world.Allocate("exit")
+	door2.Name = "<O>utside;o;outside"
+	door2.Description = "a door"
+	door2.Next = outside.ID
+	door2.Commit()
+
+	door3, _ := world.Allocate("exit")
+	door3.Name = "<K>itchen;k;kitchen"
+	door3.Description = "a door"
+	door3.Next = kitchen.ID
+	door3.Commit()
+
+	door4, _ := world.Allocate("exit")
+	door4.Name = "<H>ouse;h;house"
+	door4.Description = "a door"
+	door4.Next = kitchen.ID
+	door4.Commit()
+
+	kitchen.Contains(&door1)
+	kitchen.Contains(&door2)
+	bathroom.Contains(&door3)
+	outside.Contains(&door4)
+
+	keelan, _ := world.CreatePlayer("keelan")
+	kitchen.Contains(&keelan)
+
+	dan, _ := world.CreatePlayer("dan")
+	bathroom.Contains(&dan)
+}

event_distributor.go

@@ -0,0 +1,114 @@
+package funmow
+
+const (
+	EventTypeEmit  = iota // everyone in the containing object hears it,
+	EventTypeOEmit        // everyone in the containing object except the player hears it
+	EventTypePEmit        // only the player hears it
+	EventTypeWall         // broadcast message
+	EventTypePage
+	EventTypeSay
+	EventTypePose
+)
+
+type PlayerEvent struct {
+	src         DBRef
+	dst         DBRef
+	messageType int
+	audience    DBRef
+	message     string
+}
+
+type EventDistributor struct {
+	subscribeChan chan EventSubscribeRequest
+	whoChan       chan chan DBRefList
+}
+
+func NewEventDistributor() *EventDistributor {
+	e := new(EventDistributor)
+	e.subscribeChan = make(chan EventSubscribeRequest)
+	e.whoChan = make(chan chan DBRefList)
+	return e
+}
+
+func (e *EventDistributor) Subscribe(subReq EventSubscribeRequest) EventChanSet {
+	e.subscribeChan <- subReq
+	outbound := <-subReq.chanSet
+	return outbound
+}
+
+func (e *EventDistributor) OnlinePlayers() DBRefList {
+	replyChan := make(chan DBRefList)
+	e.whoChan <- replyChan
+	onlinePlayers := <-replyChan
+	return onlinePlayers
+}
+
+func (e *EventDistributor) Run() {
+
+	chanSet := EventChanSet{
+		messageChan:  make(chan PlayerEvent),
+		shutdownChan: make(chan int),
+	}
+
+	ipcChans := make(map[int]playerRegistration)
+
+	for {
+		select {
+		case sub := <-e.subscribeChan:
+			ipcChans[sub.connectionID] = playerRegistration{ID: sub.playerID, inbound: sub.inbound}
+			sub.chanSet <- chanSet
+		case connectionID := <-chanSet.shutdownChan:
+			delete(ipcChans, connectionID)
+		case message := <-chanSet.messageChan:
+			go func() {
+				for _, player := range ipcChans {
+					switch message.messageType {
+					case EventTypeEmit:
+						player.inbound <- message // looks like a wall because this goroutine doesn't know where the player is
+					case EventTypeOEmit:
+						if message.dst != player.ID {
+							player.inbound <- message
+						}
+					case EventTypePEmit:
+						if message.dst == player.ID {
+							player.inbound <- message
+						}
+					case EventTypeWall:
+						player.inbound <- message
+					case EventTypePage:
+						if message.dst == player.ID {
+							player.inbound <- message
+						}
+					case EventTypeSay:
+						player.inbound <- message
+					case EventTypePose:
+						player.inbound <- message
+					}
+				}
+			}()
+		case replyChan := <-e.whoChan:
+			onlinePlayers := make(DBRefList, 0)
+			for _, player := range ipcChans {
+				onlinePlayers = append(onlinePlayers, player.ID)
+			}
+			replyChan <- onlinePlayers
+		}
+	}
+}
+
+type playerRegistration struct {
+	ID      DBRef
+	inbound chan PlayerEvent
+}
+
+type EventSubscribeRequest struct {
+	connectionID int
+	playerID     DBRef
+	inbound      chan PlayerEvent
+	chanSet      chan EventChanSet
+}
+
+type EventChanSet struct {
+	messageChan  chan PlayerEvent
+	shutdownChan chan int
+}

object.go

@@ -0,0 +1,195 @@
+package funmow
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+const (
+	MatchNone = iota
+	MatchOne
+	MatchMany
+)
+
+type Object struct {
+	ID          DBRef                      `json:"id"`
+	Next        DBRef                      `json:"next"`
+	Type        string                     `json:"type"`
+	Name        string                     `json:"name"`
+	Description string                     `json:"description"`
+	Links       map[string]map[string]bool `json:"links"`
+	Inside      DBRef                      `json:"inside"`
+	Owner       DBRef                      `json:"owner"`
+	world       *Store
+}
+
+func (o *Object) Commit() error {
+	return o.world.StoreObject(o)
+}
+
+func (o *Object) Refresh() bool {
+	found := o.world.RetrieveObject(o)
+	return found
+}
+
+func (o *Object) Link(c *Object) {
+	if o.Links == nil {
+		o.Links = make(map[string]map[string]bool)
+	}
+	if o.Links[c.Type] == nil {
+		o.Links[c.Type] = make(map[string]bool)
+	}
+	o.Links[c.Type][c.ID.String()] = true
+}
+
+func (o *Object) Unlink(c *Object) {
+	if o.Links == nil || o.Links[c.Type] == nil {
+		return
+	}
+	delete(o.Links[c.Type], c.ID.String())
+}
+
+func (o Object) String() string {
+	return fmt.Sprintf("id %d: %s", o.ID, o.Name)
+}
+
+func (o *Object) Remove(c *Object) error {
+	return o.world.Unlink(o.ID, c.ID)
+}
+
+func (o *Object) Contains(c *Object) error {
+	return o.world.Link(o.ID, c.ID)
+}
+
+func (o *Object) MatchLinkNames(matchName string, player DBRef, excludePlayer bool) ObjectList {
+	if matchName == "here" {
+		return ObjectList{*o}
+	}
+	if !excludePlayer && matchName == "me" {
+		p, found := o.world.Fetch(player)
+		if !found {
+			return ObjectList{}
+		} else {
+			return ObjectList{p}
+		}
+	}
+	r := make(ObjectList, 0)
+	if o.Links == nil {
+		return r
+	}
+	for _, links := range o.Links {
+		if links == nil {
+			continue
+		}
+		for id, _ := range links {
+			v, _ := NewDBRefFromString(id)
+			if excludePlayer && player == v {
+				continue
+			}
+			o, found := o.world.Fetch(v)
+			if found {
+				idName := fmt.Sprintf("#%d", o.ID)
+				lowerObjectName := strings.ToLower(o.Name)
+				lowerMatchName := strings.ToLower(matchName)
+				if strings.HasPrefix(lowerObjectName, lowerMatchName) || matchName == idName {
+					r = append(r, o)
+				}
+			}
+		}
+	}
+	return r
+}
+
+func (o *Object) MatchExitNames(name string) ObjectList { // so much copypasta
+	r := make(ObjectList, 0)
+	if o.Links == nil {
+		return r
+	}
+	for _, links := range o.Links {
+		if links == nil {
+			continue
+		}
+		for id, _ := range links {
+			v, _ := NewDBRefFromString(id)
+			o, found := o.world.Fetch(v)
+			if found {
+				idName := fmt.Sprintf("#%d", v)
+
+				if strings.EqualFold(o.Name, name) || name == idName {
+					r = append(r, o)
+				}
+
+				aliases := strings.FieldsFunc(o.Name, func(c rune) bool {
+					return c == ';'
+				})
+				for _, v := range aliases {
+					if v == name {
+						r = append(r, o)
+					}
+				}
+
+			}
+		}
+	}
+	return r
+}
+
+func (o *Object) DetailedName() string {
+	return fmt.Sprintf("%s (#%d)", o.Name, o.ID)
+}
+
+func (o *Object) GetLinkNames(matchType string, exclude DBRefList) []string {
+	r := make([]string, 0)
+	if o.Links == nil {
+		return r
+	}
+	for linkType, links := range o.Links {
+		if matchType != "*" && matchType != linkType {
+			continue
+		}
+		if links == nil {
+			continue
+		}
+		for id, _ := range links {
+			v, _ := NewDBRefFromString(id)
+			skip := false
+			for _, excludeID := range exclude {
+				if excludeID == v {
+					skip = true
+				}
+			}
+			if skip {
+				continue
+			}
+			o, found := o.world.Fetch(v)
+			if found {
+				r = append(r, o.DetailedName())
+			}
+		}
+	}
+	sort.Strings(r)
+	return r
+}
+
+type ObjectList []Object
+
+func (l ObjectList) First() Object {
+	if len(l) > 0 {
+		return l[0]
+	} else {
+		return Object{}
+	}
+}
+
+func (l ObjectList) ExactlyOne() (Object, int) {
+	c := len(l)
+
+	if c == 0 {
+		return Object{}, MatchNone
+	} else if c == 1 {
+		return l[0], MatchOne
+	} else {
+		return Object{}, MatchMany
+	}
+}

world.go

@@ -0,0 +1,308 @@
+package funmow
+
+import (
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"github.com/boltdb/bolt"
+	"strconv"
+)
+
+type DBRef int
+
+func NewDBRefFromHashRef(v string) (DBRef, error) {
+	var destInt int
+	_, err := fmt.Sscanf(v, "#%d", &destInt)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return DBRef(destInt), nil
+}
+
+func NewDBRefFromString(v string) (DBRef, error) {
+	intVal, err := strconv.Atoi(v)
+	return DBRef(intVal), err
+}
+
+func (r DBRef) Valid() bool {
+	return r != 0
+}
+
+func (r DBRef) String() string {
+	return strconv.Itoa(int(r))
+}
+
+type DBRefList []DBRef
+
+func (l DBRefList) First() DBRef {
+	if len(l) > 0 {
+		return l[0]
+	} else {
+		return 0
+	}
+}
+
+type Store struct {
+	path string
+	db   *bolt.DB
+}
+
+func NewDB(path string) *Store {
+	return &Store{path: path}
+}
+
+func (s *Store) Close() {
+	s.db.Close()
+}
+
+func (s *Store) Open() error {
+	var err error
+	s.db, err = bolt.Open(s.path, 0600, nil)
+	if err != nil {
+		return err
+	}
+	return s.db.Update(func(tx *bolt.Tx) error {
+		var err error
+		_, err = tx.CreateBucketIfNotExists([]byte("object"))
+		if err != nil {
+			return fmt.Errorf("create bucket: %s", err)
+		}
+		_, err = tx.CreateBucketIfNotExists([]byte("player"))
+		if err != nil {
+			return fmt.Errorf("create bucket: %s", err)
+		}
+		return nil
+	})
+}
+
+func (s *Store) Link(newContainerRef DBRef, objectRef DBRef) error {
+
+	return s.db.Update(func(tx *bolt.Tx) error {
+		// TODO: if this transaction fails, it will leave the local objects in an
+		// inconsistent altered state, which isn't cool.
+		b := tx.Bucket([]byte("object"))
+
+		o := &Object{ID: objectRef}
+
+		if !txRetrieveObject(b, o) {
+			return errors.New("target object does not exist")
+		}
+
+		newContainer := &Object{ID: newContainerRef}
+
+		if !txRetrieveObject(b, newContainer) {
+			return errors.New("destination object does not exist")
+		}
+
+		haveOldContainer := false
+		oldContainer := &Object{ID: o.Inside}
+		if o.Inside.Valid() {
+			haveOldContainer = txRetrieveObject(b, oldContainer)
+			if haveOldContainer {
+				oldContainer.Unlink(o)
+			}
+		}
+
+		newContainer.Link(o)
+
+		o.Inside = newContainer.ID
+
+		err := txStoreObject(b, o)
+		if err != nil {
+			return err
+		}
+
+		if haveOldContainer {
+			err = txStoreObject(b, oldContainer)
+			if err != nil {
+				return err
+			}
+		}
+
+		err = txStoreObject(b, newContainer)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	})
+}
+
+func (s *Store) Unlink(newContainerRef DBRef, objectRef DBRef) error {
+
+	return s.db.Update(func(tx *bolt.Tx) error {
+		// TODO: if this transaction fails, it will leave the local objects in an
+		// inconsistent altered state, which isn't cool.
+		b := tx.Bucket([]byte("object"))
+
+		o := &Object{ID: objectRef}
+
+		if !txRetrieveObject(b, o) {
+			return errors.New("target object does not exist")
+		}
+
+		if o.Inside.Valid() {
+			oldContainer := &Object{ID: o.Inside}
+			if txRetrieveObject(b, oldContainer) {
+				oldContainer.Unlink(o)
+
+				o.Inside = 0
+
+				err := txStoreObject(b, o)
+				if err != nil {
+					return err
+				}
+
+				err = txStoreObject(b, oldContainer)
+				if err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	})
+}
+
+func (s *Store) Allocate(t string) (Object, error) {
+	var o Object
+	err := s.db.Update(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte("object"))
+		id, err := b.NextSequence()
+		if err != nil {
+			return err
+		}
+		o.ID = DBRef(id)
+		o.Type = t
+		return txStoreObject(b, &o)
+	})
+	o.world = s
+	return o, err
+}
+
+func (s *Store) Fetch(r DBRef) (Object, bool) {
+	o := Object{ID: r}
+	found := s.RetrieveObject(&o)
+	return o, found
+}
+
+func (s *Store) GetName(r DBRef) string {
+	if r == 0 {
+		return ""
+	} else {
+		o := Object{ID: r}
+		if s.RetrieveObject(&o) {
+			return o.DetailedName()
+		} else {
+			return fmt.Sprintf("#%d MISSING", r)
+		}
+	}
+}
+
+func (s *Store) DumpObject(r DBRef) string {
+	var dump string
+	s.db.View(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte("object"))
+		dump = string(b.Get(itob(int(r))))
+		return nil
+	})
+	return dump
+}
+
+func (s *Store) RetrieveObject(o *Object) bool {
+	found := false
+	s.db.View(func(tx *bolt.Tx) error { // thats right i throw away an error
+		b := tx.Bucket([]byte("object"))
+		found = txRetrieveObject(b, o)
+		return nil
+	})
+	o.world = s
+	return found
+}
+
+func (s *Store) StoreObject(o *Object) error {
+	return s.db.Update(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte("object"))
+		return txStoreObject(b, o)
+	})
+}
+
+func (s *Store) SetPlayerID(playername string, id DBRef) error {
+	err := s.db.Update(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte("player"))
+		if b == nil {
+			return errors.New("Player bucket not found")
+		}
+		return b.Put([]byte(playername), []byte(id.String()))
+	})
+	return err
+}
+
+func (s *Store) GetPlayerID(playername string) (DBRef, error) {
+	var id DBRef
+	err := s.db.View(func(tx *bolt.Tx) error {
+		var err error
+		b := tx.Bucket([]byte("player"))
+		if b == nil {
+			return errors.New("Player bucket not found")
+		}
+		v := b.Get([]byte(playername))
+		if v == nil {
+			return errors.New("Player not found")
+		}
+		id, err = NewDBRefFromString(string(v))
+		return err
+	})
+	return id, err
+}
+
+func (s *Store) CreatePlayer(name string) (Object, error) {
+	player, err := s.Allocate("player")
+	if err != nil {
+		return player, err
+	}
+	player.Name = name
+	player.Owner = player.ID
+	player.Commit()
+	err = s.SetPlayerID(name, player.ID)
+	return player, err
+}
+
+func txRetrieveObject(b *bolt.Bucket, o *Object) bool {
+	v := b.Get(itob(int(o.ID)))
+	if v == nil {
+		return false // doesn't exist
+	}
+	//fmt.Println("txRetrieveObject", o.ID.String(), string(v))
+	err := json.Unmarshal(v, o)
+	if err != nil {
+		// We should log this. the object exists but can't be de-serialized.
+		// We'll just pretend it doesn't exist for now.
+		return false
+	}
+	return true
+}
+
+func txStoreObject(b *bolt.Bucket, o *Object) error {
+	buf, err := json.Marshal(o)
+	//fmt.Println("txStoreObject", o.ID.String(), string(buf))
+	if err != nil {
+		fmt.Println(err)
+		return err
+	}
+	err = b.Put(itob(int(o.ID)), buf)
+	if err != nil {
+		fmt.Println(err)
+		return err
+	}
+	return nil
+}
+
+// itob returns an 8-byte big endian representation of v.
+func itob(v int) []byte {
+	b := make([]byte, 8)
+	binary.BigEndian.PutUint64(b, uint64(v))
+	return b
+}