Seperated game logic from connection logic so that game logic can be run by objects like they are players.

client.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"log"
 	"net"
-	"regexp"
 	"strings"
 	"unicode"
 )
@@ -13,13 +12,13 @@ import (
 type Client struct {
 	conn             net.Conn
 	connectionID     int
-	player           Object
+	playerID         DBRef
 	authenticated    bool
 	connected        bool
 	reader           *bufio.Reader
 	commandChan      chan string
 	inbound          chan PlayerEvent
-	outbound         EventChanSet
+	outbound         chan PlayerEvent
 	eventDistributor *EventDistributor
 	db               *DB
 	factory          *ObjectFactory
@@ -64,66 +63,20 @@ func (c *Client) Run() {
 	for c.connected {
 		select {
 		case m := <-c.inbound:
-			inside, _ := c.db.GetParent(c.player.ID)
-			switch m.messageType {
-			case EventTypeEmit:
-				fallthrough
-			case EventTypeOEmit:
-				if m.audience == inside {
-					c.write("%s\n", m.message)
-				}
-			case EventTypePEmit:
-				c.write("%s\n", m.message)
-			case EventTypeWall:
-				speaker, found := c.db.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.db.Fetch(m.src)
-				if !found {
-					break
-				}
-				c.write("%s pages you: \"%s\"\n", speaker.Name, m.message)
-			case EventTypeSay:
-				if m.audience == inside {
-					if m.src == c.player.ID {
-						c.write("You say \"%s\"\n", m.message)
-					} else {
-						speaker, found := c.db.Fetch(m.src)
-						if !found {
-							break
-						}
-						c.write("%s says \"%s\"\n", speaker.Name, m.message)
-					}
-				}
-			case EventTypePose:
-				if m.audience == inside {
-					if m.src == c.player.ID {
-						c.write("%s %s\n", c.player.Name, m.message)
-					} else {
-						speaker, found := c.db.Fetch(m.src)
-						if !found {
-							break
-						}
-						c.write("%s %s\n", speaker.Name, m.message)
-					}
-				}
-			}
+			c.handleInboundEvent(m)
 		case cmd := <-c.commandChan:
 			if c.authenticated {
-				c.handlePlayPhase(cmd)
+				c.sendCommand(cmd)
 			} else {
 				c.handleLoginPhase(cmd)
 			}
 		}
 	}
-	if c.authenticated {
-		c.outbound.shutdownChan <- c.connectionID
-	}
+
 	c.conn.Close()
 
+	c.outbound <- PlayerEvent{src: c.playerID, dst: c.playerID, messageType: EventTypeTeardown, connectionID: c.connectionID}
+
 	log.Print("Lost connection from ", c.conn.RemoteAddr())
 
 }
@@ -151,688 +104,49 @@ func (c *Client) handleLoginPhase(message string) {
 		fallthrough
 	case "connect":
 		if len(fields) == 3 {
-			pID, err := c.db.GetPlayerID(fields[1])
+			playerID, err := c.db.GetPlayerID(fields[1])
 			if err != nil {
 				c.write("Bad username or password.\n")
 				break
 			}
-			player, found := c.db.Fetch(pID)
-			if !found {
-				c.write("You appear to be having an existential crisis.\n")
-				c.connected = false
-				break
-			}
 
+			c.playerID = playerID
 			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,
+				playerID:     c.playerID,
 				inbound:      c.inbound,
-				chanSet:      make(chan EventChanSet),
+				outbound:     make(chan chan PlayerEvent),
 			}
 
 			c.outbound = c.eventDistributor.Subscribe(subReq)
-
-			c.write("Welcome back, %s!\n", fields[1])
-
-			c.lookCmd("")
-
+			c.sendCommand("look")
 		} else {
 			c.write("What?\n")
 		}
 	case "quit":
-		c.quitCmd()
+		c.connected = false
 	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(message)
-	case strings.HasPrefix(message, "@open "):
-		c.openCmd(message)
-	case strings.HasPrefix(message, "@name "):
-		c.nameCmd(message)
-	case strings.HasPrefix(message, "@desc "):
-		c.descCmd(message)
-	case strings.HasPrefix(message, "@tel "):
-		c.telCmd(strings.TrimPrefix(message, "@tel "))
-	case strings.HasPrefix(message, "@dump "):
-		c.dumpCmd(strings.TrimPrefix(message, "@dump "))
-	case strings.HasPrefix(message, "@destroy "):
-		c.destroyCmd(strings.TrimPrefix(message, "@destroy "))
-	default:
-		if !c.goCmd(message) {
-			c.write("What?\n")
-		}
-	}
-
-}
-
-func (c *Client) lookCmd(at string) {
-
-	roomID, found := c.db.GetParent(c.player.ID)
-	room, found := c.db.Fetch(roomID)
-	if !found {
-		c.write("True Limbo (#NaN)\nThere's nothing to see here. You are inside an object that doesn't exist.\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(&room, "thing", "Things:")
-		c.lookLinks(&room, "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) objectName(id DBRef) string {
-	o, found := c.db.Fetch(id)
-	if found {
-		return o.DetailedName()
-	} else {
-		return fmt.Sprintf("MISSING OBJECT (#%d)", id)
-	}
-}
-
-func (c *Client) examineCmd(at string) {
-
-	roomID, found := c.db.GetParent(c.player.ID)
-	room, found := c.db.Fetch(roomID)
-	if !found {
-		return
-	}
-
-	object, matchType := room.MatchLinkNames(at, c.player.ID, false).ExactlyOne()
-
-	switch matchType {
-	case MatchOne:
-
-		objectParentID, _ := c.db.GetParent(object.ID)
-
-		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.objectName(objectParentID))
-		c.write("Next: %s\n", c.objectName(object.Next))
-		c.write("Owner: %s\n", c.objectName(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(o *Object, linkType string, pretty string) {
-
-	linknames := o.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) {
-
-	inside, _ := c.db.GetParent(c.player.ID)
-	c.outbound.messageChan <- PlayerEvent{audience: inside, src: c.player.ID, message: message, messageType: EventTypeSay}
-
-}
-
-func (c *Client) poseCmd(message string) {
-
-	inside, _ := c.db.GetParent(c.player.ID)
-	c.outbound.messageChan <- PlayerEvent{audience: 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) {
-
-	roomID, found := c.db.GetParent(c.player.ID)
-	room, found := c.db.Fetch(roomID)
-	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) {
-
-	roomID, found := c.db.GetParent(c.player.ID)
-	room, found := c.db.Fetch(roomID)
-	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
-		}
-		inside, _ := c.db.GetParent(c.player.ID)
-		c.player.Refresh()
-		c.write("You drop %s.\n", object.Name)
-		c.oemit(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) {
-
-	roomID, found := c.db.GetParent(c.player.ID)
-	room, found := c.db.Fetch(roomID)
-	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() {
-
-	inside, _ := c.db.GetParent(c.player.ID)
-	object, found := c.db.Fetch(inside)
-	if !found {
-		return
-	}
-	objectInside, _ := c.db.GetParent(inside)
-	if objectInside == 0 { // probably trying to 'leave' a room
-		c.write("You can't leave here.\n")
-		return
-	}
-
-	room, found := c.db.Fetch(objectInside)
-	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.db.GetName(ref))
-	//}
-}
-
-func (c *Client) createCmd(message string) {
-
-	roomID, found := c.db.GetParent(c.player.ID)
-	room, found := c.db.Fetch(roomID)
-	if !found {
-		return
-	}
-
-	o := c.factory.NewThing()
-	o.Name = strings.TrimSpace(message)
-	o.Owner = c.player.ID
-	o.Commit()
-
-	err := room.Contains(&o)
-	if err != nil {
-		return
+func (c *Client) handleInboundEvent(m PlayerEvent) {
+	switch m.messageType {
+	case EventTypeOutput:
+		c.write("%s\n", m.message)
+	case EventTypeQuit:
+		c.connected = false
 	}
-
-	c.emit(room.ID, "A %s appears out of the ether.", o.Name)
-	c.write("%s Created.\n", o.DetailedName())
-
-}
-
-func (c *Client) openCmd(input string) {
-	// @open <in1;in2;in3;etc>=#<room>,<out1;out2;out3;etc>
-
-	r, _ := regexp.Compile(`^@open\pZ+([^=]*[^=\pZ]+)\pZ*=#([0-9]+)(?:\pZ*,\pZ*([^,]*[^,\pZ]+)\pZ*)?`)
-	params := r.FindStringSubmatch(input)
-
-	if params == nil {
-		return
-	}
-
-	inExit, roomIDStr, outExit := params[1], params[2], params[3]
-
-	if len(inExit) == 0 || len(roomIDStr) == 0 {
-		c.write("Bad command or file name.\n")
-		return
-	}
-
-	targetID, _ := NewDBRefFromString(roomIDStr) // this will never fail, the regexp guarantees that
-	targetRoom, found := c.db.Fetch(targetID)
-	if !found {
-		c.write("Target not found.\n")
-		return
-	}
-
-	roomID, found := c.db.GetParent(c.player.ID)
-	room, found := c.db.Fetch(roomID)
-	if !found {
-		return
-	}
-
-	toExit := c.factory.NewExit(inExit, targetRoom.ID, c.player.ID)
-	toExit.Commit()
-	err := room.Contains(&toExit)
-	if err != nil {
-		return
-	}
-	c.write("%s Created.\n", toExit.DetailedName())
-
-	if len(outExit) > 0 {
-		fromExit := c.factory.NewExit(outExit, room.ID, c.player.ID)
-		fromExit.Commit()
-		err = targetRoom.Contains(&fromExit)
-		if err != nil {
-			return
-		}
-		c.write("%s Created.\n", fromExit.DetailedName())
-	}
-
-}
-
-func (c *Client) digCmd(input string) {
-	// @dig <Room name>=<in1;in2;in3;etc>,<out1;out2;out3;etc>
-	//@dig foo bar  = <F>oo;foo;f,<B>ack;back;b
-
-	r, _ := regexp.Compile(`^@dig\pZ+([^=]*[^=\pZ]+)(\pZ*=\pZ*(?:([^,]*[^,\pZ]+)\pZ*)?(?:\pZ*,\pZ*([^,]*[^,\pZ]+)\pZ*)?)?`)
-	params := r.FindStringSubmatch(input)
-	if params == nil {
-		return
-	}
-
-	roomName, inExit, outExit := params[1], params[2], params[3]
-
-	if len(roomName) == 0 {
-		c.write("Rooms can't not have names.\n")
-		return
-	}
-
-	newRoom := c.factory.NewRoom()
-	newRoom.Name = roomName
-	newRoom.Owner = c.player.ID
-	newRoom.Commit()
-
-	c.write("%s Created.\n", newRoom.DetailedName())
-
-	if len(inExit) > 0 || len(outExit) > 0 {
-		roomID, found := c.db.GetParent(c.player.ID)
-		room, found := c.db.Fetch(roomID)
-		if !found {
-			return
-		}
-		if len(inExit) > 0 {
-			toExit := c.factory.NewExit(inExit, newRoom.ID, c.player.ID)
-			toExit.Commit()
-			err := room.Contains(&toExit)
-			if err != nil {
-				return
-			}
-			c.write("%s Created.\n", toExit.DetailedName())
-		}
-		if len(outExit) > 0 {
-			fromExit := c.factory.NewExit(outExit, room.ID, c.player.ID)
-			fromExit.Commit()
-			err := newRoom.Contains(&fromExit)
-			if err != nil {
-				return
-			}
-			c.write("%s Created.\n", fromExit.DetailedName())
-		}
-	}
-
-}
-
-func (c *Client) nameCmd(input string) {
-
-	r, _ := regexp.Compile(`^@name\pZ+([^=]*[^=\pZ]{1})\pZ*=\pZ*(.*)\pZ*$`)
-	params := r.FindStringSubmatch(input)
-	if params == nil {
-		return
-	}
-
-	objectName, name := params[1], params[2]
-
-	roomID, found := c.db.GetParent(c.player.ID)
-	room, found := c.db.Fetch(roomID)
-	if !found {
-		return
-	}
-
-	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(input string) {
-
-	r, _ := regexp.Compile(`^@desc\pZ+([^=]*[^=\pZ]{1})\pZ*=\pZ*(.*)\pZ*$`)
-	params := r.FindStringSubmatch(input)
-	if params == nil {
-		return
-	}
-
-	objectName, description := params[1], params[2]
-
-	roomID, found := c.db.GetParent(c.player.ID)
-	room, found := c.db.Fetch(roomID)
-
-	if !found {
-		return
-	}
-
-	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.db.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.db.Fetch(ref)
-	if !found {
-		c.write("That doesn't exist.\n")
-		return
-	}
-
-	c.write("%s\n", c.db.DumpObject(obj.ID))
-
-}
-
-func (c *Client) destroyCmd(message string) {
-
-	roomID, found := c.db.GetParent(c.player.ID)
-	room, found := c.db.Fetch(roomID)
-	if !found {
-		return
-	}
-
-	object, matchType := room.MatchLinkNames(message, c.player.ID, true).ExactlyOne()
-
-	switch matchType {
-	case MatchOne:
-		name := object.DetailedName()
-		err := object.Delete()
-		if err == nil {
-			c.player.Refresh()
-			c.write("%s vanishes into thin air.\n", 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) goCmd(dir string) bool {
-
-	roomID, found := c.db.GetParent(c.player.ID)
-	room, found := c.db.Fetch(roomID)
-	if !found {
-		return false
-	}
-
-	exit, matchType := room.MatchExitNames(dir).ExactlyOne()
-	switch matchType {
-	case MatchOne:
-		if exit.Next.Valid() {
-			newRoom, found := c.db.Fetch(exit.Next)
-			if !found {
-				c.write("That exit appears to be broken!\n")
-				return true
-			}
-			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}
-
+func (c *Client) sendCommand(message string) {
+	c.outbound <- PlayerEvent{src: c.playerID, dst: c.playerID, message: message, messageType: EventTypeCommand, connectionID: c.connectionID}
 }

cmd/funmow/main.go

@@ -32,7 +32,7 @@ func main() {
 
 	log.Print("Starting event distributor...")
 
-	e := funmow.NewEventDistributor()
+	e := funmow.NewEventDistributor(db)
 	go e.Run()
 
 	log.Print("Waiting for connections...")
@@ -51,7 +51,6 @@ func seedDB(db *funmow.DB) {
 	f := funmow.NewObjectFactory(db)
 
 	keelan, _ := db.CreatePlayer("keelan")
-
 	dan, _ := db.CreatePlayer("dan")
 
 	outside := f.NewObject()

db.go

@@ -10,13 +10,17 @@ import (
 	"strconv"
 )
 
+const (
+	DEBUG = false
+)
+
 type DBRef int
 
 func NewDBRefFromHashRef(v string) (DBRef, error) {
 	var destInt int
-	_, err := fmt.Sscanf(v, "#%d", &destInt)
+	n, err := fmt.Sscanf(v, "#%d", &destInt)
 
-	if err != nil {
+	if err != nil || n == 0 {
 		return 0, err
 	}
 
@@ -140,14 +144,29 @@ func (s *DB) Allocate() (DBRef, error) {
 }
 
 func (s *DB) Fetch(r DBRef) (Object, bool) { // this has become simply an alias for RetrieveObject
+
 	return s.RetrieveObject(r)
 }
 
 func (s *DB) DumpObject(r DBRef) string {
 	var dump string
 	s.db.View(func(tx *bolt.Tx) error {
-		b := tx.Bucket([]byte("object"))
-		dump = string(b.Get(r.Key()))
+		objectBucket := tx.Bucket([]byte("object"))
+		childBucket := tx.Bucket([]byte("child"))
+		parentBucket := tx.Bucket([]byte("parent"))
+
+		objectDump := string(objectBucket.Get(r.Key()))
+
+		intermediate := make([]string, 0)
+		children := s.txGetChildren(childBucket, r)
+		for childID, childType := range children {
+			intermediate = append(intermediate, fmt.Sprintf("#%d (%s)", childID, childType))
+		}
+
+		parent, hasParent := s.txGetParent(parentBucket, r)
+
+		dump = fmt.Sprintf("Object: %s\nHas Parent: %t\nParent ID: #%d\nChildren: %s", objectDump, hasParent, parent, intermediate)
+
 		return nil
 	})
 	return dump
@@ -205,37 +224,52 @@ func (s *DB) Delete(objectID DBRef) error {
 		if err != nil {
 			return err
 		}
+
+		if DEBUG {
+			fmt.Printf("Delete name: id: %d\n", objectID)
+		}
+
 		return nil
 	})
 }
 
-func (s *DB) SetPlayerID(playername string, id DBRef) error {
+func (s *DB) SetPlayerID(name 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), id.Key())
+		return b.Put([]byte(name), id.Key())
 	})
+
+	if DEBUG {
+		fmt.Printf("SetPlayerID name: %s id: %d\n", name, id)
+	}
+
 	return err
 
 }
 
-func (s *DB) GetPlayerID(playername string) (DBRef, error) {
+func (s *DB) GetPlayerID(name string) (DBRef, error) {
 	var id DBRef
 	err := s.db.View(func(tx *bolt.Tx) error {
 		b := tx.Bucket([]byte("player"))
 		if b == nil {
 			return errors.New("Player bucket not found")
 		}
-		v := b.Get([]byte(playername))
+		v := b.Get([]byte(name))
 		if v == nil {
 			return errors.New("Player not found")
 		}
 		id = NewDBRefFromKey(v)
 		return nil
 	})
+
+	if DEBUG {
+		fmt.Printf("GetPlayerID name: %s id: %d\n", name, id)
+	}
+
 	return id, err
 }
 
@@ -251,11 +285,15 @@ func (s *DB) CreatePlayer(name string) (DBRef, error) {
 			return err
 		}
 		playerID = DBRef(seq)
-		s.txStoreObject(objectBucket, Object{ID: playerID, Name: name}, playerID)
+		s.txStoreObject(objectBucket, Object{ID: playerID, Name: name, Type: "player"}, playerID)
 		err = playerBucket.Put([]byte(name), playerID.Key())
 		return err
 	})
 
+	if DEBUG {
+		fmt.Printf("CreatePlayer name: %s id: %d\n", name, playerID)
+	}
+
 	return playerID, err
 }
 
@@ -284,7 +322,11 @@ func (s *DB) txRetrieveObject(b *bolt.Bucket, id DBRef) (Object, bool) {
 		err := json.Unmarshal(v, &o)
 		if err == nil {
 			f = true
-			//fmt.Println("txRetrieveObject", id.String(), string(v))
+
+			if DEBUG {
+				fmt.Printf("txRetrieveObject id: %d\n", id)
+			}
+
 		}
 	}
 	o.db = s // bit ugly but saves a lot of headaches
@@ -316,6 +358,10 @@ func (s *DB) txStoreObject(b *bolt.Bucket, o Object, id DBRef) error {
 		return err
 	}
 
+	if DEBUG {
+		fmt.Printf("txStoreObject id: %d\n", id)
+	}
+
 	return nil
 
 }
@@ -359,19 +405,23 @@ func (s *DB) GetParent(src DBRef) (DBRef, bool) {
 
 }
 
-func (s *DB) txGetParent(b *bolt.Bucket, src DBRef) (DBRef, bool) {
+func (s *DB) txGetParent(parentBucket *bolt.Bucket, childID DBRef) (DBRef, bool) {
 
-	p := DBRef(0)
+	parentID := DBRef(0)
 	f := false
 
-	v := b.Get(src.Key())
+	v := parentBucket.Get(childID.Key())
 	if v != nil {
-		p = NewDBRefFromKey(v)
+		parentID = NewDBRefFromKey(v)
 		f = true
 	}
 
+	if DEBUG {
+		fmt.Printf("txGetParent child: %d parent: %d\n", childID, parentID)
+	}
+
 	//fmt.Printf("txGetParent src: %d found: %t parent: %d\n", src, f, p)
-	return p, f
+	return parentID, f
 
 }
 
@@ -454,7 +504,9 @@ func (s *DB) txLink(childBucket *bolt.Bucket, parentBucket *bolt.Bucket, parentI
 		return err
 	}
 
-	//fmt.Printf("txLink %d is now inside %d\n", childID, parentID)
+	if DEBUG {
+		fmt.Printf("txLink parent: %d child: %d\n", parentID, childID)
+	}
 
 	return nil
 
@@ -481,12 +533,18 @@ func (s *DB) txUnlink(childBucket *bolt.Bucket, parentBucket *bolt.Bucket, paren
 		return err
 	}
 
-	//fmt.Printf("txUnlink %d has been removed from %d\n", childID, parentID)
+	if DEBUG {
+		fmt.Printf("txUnlink parent: %d child: %d\n", parentID, childID)
+	}
 
 	return nil
 
 }
 
 func (s *DB) txDelete(b *bolt.Bucket, id DBRef) error {
+	if DEBUG {
+		fmt.Printf("txDelete %d\n", id)
+	}
+
 	return b.Delete(id.Key())
 }

event_distributor.go

@@ -1,5 +1,7 @@
 package funmow
 
+import "fmt"
+
 const (
 	EventTypeEmit  = iota // everyone in the containing object hears it,
 	EventTypeOEmit        // everyone in the containing object except the player hears it
@@ -8,107 +10,177 @@ const (
 	EventTypePage
 	EventTypeSay
 	EventTypePose
+	EventTypeCommand //7
+	EventTypeOutput  //8
+	EventTypeQuit
+	EventTypeTeardown
+	EventTypeTeardownComplete
+	EventTypeForce
 )
 
 type PlayerEvent struct {
-	src         DBRef
-	dst         DBRef
-	messageType int
-	audience    DBRef
-	message     string
+	connectionID int
+	src          DBRef
+	dst          DBRef
+	messageType  int
+	message      string
+}
+
+type playerRegistration struct {
+	execContext *ExecutionContext
+	connInbound map[int]chan PlayerEvent
+	execInbound chan PlayerEvent
+}
+
+type EventSubscribeRequest struct {
+	connectionID int
+	playerID     DBRef
+	inbound      chan PlayerEvent
+	outbound     chan chan PlayerEvent
 }
 
 type EventDistributor struct {
 	subscribeChan chan EventSubscribeRequest
-	whoChan       chan chan DBRefList
+	db            *DB
+	players       map[DBRef]*playerRegistration
 }
 
-func NewEventDistributor() *EventDistributor {
+func NewEventDistributor(db *DB) *EventDistributor {
 	e := new(EventDistributor)
+	e.db = db
 	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
+func (e *EventDistributor) Subscribe(req EventSubscribeRequest) chan PlayerEvent {
+	e.subscribeChan <- req
+	outbound := <-req.outbound
 	return outbound
 }
 
 func (e *EventDistributor) OnlinePlayers() DBRefList {
-	replyChan := make(chan DBRefList)
-	e.whoChan <- replyChan
-	onlinePlayers := <-replyChan
-	return onlinePlayers
+	//replyChan := make(chan DBRefList)
+	//e.whoChan <- replyChan
+	//onlinePlayers := <-replyChan
+	//return onlinePlayers
+	return DBRefList{}
 }
 
+//[client runs quit command]
+//connection -> "quit" -> exec
+//exec -> EventTypeQuit -> connection
+//[connection stops doing connectiony stuff]
+//connection -> EventTypeTeardown -> exec
+//[exec stops, kills off goroutines]
+//exec -> EventTypeTeardownComplete -> Event Distributor
+//Event Distributor cleans up
+
+//[client dies]
+//connection -> EventTypeTeardown -> exec
+//[exec stops, kills off goroutines]
+//exec -> EventTypeTeardownComplete -> Event Distributor
+//Event Distributor cleans up
+
 func (e *EventDistributor) Run() {
 
-	chanSet := EventChanSet{
-		messageChan:  make(chan PlayerEvent),
-		shutdownChan: make(chan int),
-	}
+	//ipcChans := make(map[int]playerRegistration)
+
+	e.players = make(map[DBRef]*playerRegistration)
 
-	ipcChans := make(map[int]playerRegistration)
+	outbound := make(chan PlayerEvent)
+
+	forceContext := NewForceContext(e, e.db, outbound)
+	forceInbound := forceContext.StartInboundChannel()
 
 	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
+
+			if _, exists := e.players[sub.playerID]; !exists {
+				c := NewExecutionContext(sub.playerID, e, e.db, outbound)
+				e.players[sub.playerID] = &playerRegistration{
+					execInbound: c.StartInboundChannel(),
+					execContext: c,
+					connInbound: make(map[int]chan PlayerEvent),
+				}
+			}
+			reg := e.players[sub.playerID]
+			fmt.Println("connection id", sub.connectionID)
+			reg.connInbound[sub.connectionID] = sub.inbound
+			sub.outbound <- outbound
+		case event := <-outbound: // message
+			fmt.Printf("received message src:%d dest:%d type: %d\n", event.src, event.dst, event.messageType)
+
+			destPlayer, validDest := e.players[event.dst]
+
+			switch event.messageType {
+			case EventTypeForce:
+				forceInbound <- event
+			case EventTypeTeardownComplete:
+				if validDest {
+					delete(e.players, event.dst)
+					fmt.Println("EventTypeTeardownComplete")
+				}
+			case EventTypeOutput: // from context to connection
+				if validDest {
+					e.sendToAllConnections(destPlayer.connInbound, event)
+				}
+				//destPlayer.connInbound <- event
+			case EventTypeQuit: // from context to connection
+				if validDest {
+					e.players[event.dst].connInbound[event.connectionID] <- event
+				}
+			case EventTypeTeardown: // comes from client when connection is dropped
+				fmt.Println("received EventTypeTeardown")
+				if validDest {
+					close(e.players[event.dst].connInbound[event.connectionID])
+					delete(e.players[event.dst].connInbound, event.connectionID)
+					fmt.Println("EventTypeTeardown delete", event.connectionID, "len: ", len(e.players[event.dst].connInbound))
+					if len(e.players[event.dst].connInbound) == 0 {
+						fmt.Println("EventTypeTeardown killing exe")
+						close(e.players[event.dst].execInbound) // closing the inbound channel signals the exec to stop
 					}
 				}
-			}()
-		case replyChan := <-e.whoChan:
-			onlinePlayers := make(DBRefList, 0)
-			for _, player := range ipcChans {
-				onlinePlayers = append(onlinePlayers, player.ID)
+			case EventTypeCommand: // from connection to context
+				if validDest {
+					destPlayer.execInbound <- event
+				}
+			case EventTypePEmit:
+				if validDest {
+					destPlayer.execInbound <- event
+				}
+			case EventTypePage:
+				if validDest {
+					destPlayer.execInbound <- event
+				}
+			case EventTypeEmit:
+				e.broadcastEvent(event, false)
+			case EventTypeOEmit:
+				e.broadcastEvent(event, true) // fix
+			case EventTypeSay:
+				e.broadcastEvent(event, true)
+			case EventTypePose:
+				e.broadcastEvent(event, false)
+			case EventTypeWall:
+				e.broadcastEvent(event, false)
 			}
-			replyChan <- onlinePlayers
 		}
 	}
 }
 
-type playerRegistration struct {
-	ID      DBRef
-	inbound chan PlayerEvent
-}
+func (e *EventDistributor) sendToAllConnections(connections map[int]chan PlayerEvent, event PlayerEvent) {
+
+	for _, channel := range connections {
+		channel <- event
+	}
 
-type EventSubscribeRequest struct {
-	connectionID int
-	playerID     DBRef
-	inbound      chan PlayerEvent
-	chanSet      chan EventChanSet
 }
 
-type EventChanSet struct {
-	messageChan  chan PlayerEvent
-	shutdownChan chan int
+func (e *EventDistributor) broadcastEvent(event PlayerEvent, omitSrc bool) {
+	for playerID, player := range e.players {
+		if !omitSrc || playerID != event.src {
+			player.execInbound <- event
+		}
+	}
 }

execution_context.go

@@ -0,0 +1,881 @@
+package funmow
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"time"
+)
+
+type ExecutionContext struct {
+	actor            Object
+	inbound          chan PlayerEvent
+	outbound         chan PlayerEvent
+	eventDistributor *EventDistributor
+	db               *DB
+	factory          *ObjectFactory
+	forceContext     bool
+}
+
+func NewForceContext(e *EventDistributor, w *DB, outbound chan PlayerEvent) *ExecutionContext {
+
+	c := new(ExecutionContext)
+
+	c.outbound = outbound
+	c.eventDistributor = e
+	c.db = w
+	c.factory = NewObjectFactory(w)
+	c.forceContext = true
+	return c
+}
+
+func NewExecutionContext(actorID DBRef, e *EventDistributor, w *DB, outbound chan PlayerEvent) *ExecutionContext {
+
+	c := new(ExecutionContext)
+
+	actor, found := w.Fetch(actorID)
+	if !found {
+		return nil
+	}
+
+	c.actor = actor
+	c.outbound = outbound
+	c.eventDistributor = e
+	c.db = w
+	c.factory = NewObjectFactory(w)
+
+	return c
+}
+
+func (c *ExecutionContext) StartInboundChannel() chan PlayerEvent {
+	c.inbound = make(chan PlayerEvent)
+	inboundBuffer := make(chan PlayerEvent)
+	c.outbound = c.outbound
+
+	go func() {
+		//inbound event buffer to protect the event distributor from long running tasks
+		// the alternative is to run each inbound event in a separate goroutine
+		// but that has potential problems (ie, two emits arrive in order.  the first one
+		// requires an extra DB lookup to sort out context. now the second one ends up
+		// sending its output event before the first, and the client sees things backwards
+		// this isn't just an edge case,  it happens quite frequently.
+		// The alternative is to buffer inbound events, which is the safest, as it doesn't
+		// impact the eventdistributor.
+
+		queue := make([]*PlayerEvent, 0)
+		running := true
+		for running {
+			if len(queue) == 0 {
+				select {
+				case newEvent, ok := <-c.inbound:
+					if !ok {
+						running = false
+						break
+					}
+					queue = append(queue, &newEvent)
+				}
+			} else {
+				event := queue[0]
+				select {
+				case newEvent, ok := <-c.inbound:
+					if !ok {
+						running = false
+						break
+					}
+					queue = append(queue, &newEvent)
+				case inboundBuffer <- *event:
+					queue = queue[1:]
+				}
+			}
+		}
+		// closure of c.inbound is the signal from the event distributor that we need to die.
+		// we then close  inboundBuffer to tell the event goroutine to die
+		fmt.Println("close(inboundBuffer)")
+		close(inboundBuffer)
+	}()
+
+	go func() {
+		for {
+			event, ok := <-inboundBuffer
+			if !ok {
+				break
+			}
+			c.HandleEvent(event)
+		}
+		// and finally we tell the event distributor to delete us.
+		fmt.Println("Sending EventTypeTeardownComplete")
+		c.outbound <- PlayerEvent{src: c.actor.ID, dst: c.actor.ID, messageType: EventTypeTeardownComplete}
+
+	}()
+
+	return c.inbound
+}
+
+func (c *ExecutionContext) HandleEvent(m PlayerEvent) {
+	inside, _ := c.db.GetParent(c.actor.ID)
+	switch m.messageType {
+	case EventTypeEmit:
+		fallthrough
+	case EventTypeOEmit:
+		if m.dst == inside {
+			c.output("%s", m.message)
+		}
+	case EventTypePEmit:
+		c.output("%s", m.message)
+	case EventTypeWall:
+		speaker, found := c.db.Fetch(m.src)
+		if !found {
+			break
+		}
+		c.output("In the distance, you hear %s bellow out \"%s\"", speaker.Name, m.message)
+	case EventTypePage:
+		speaker, found := c.db.Fetch(m.src)
+		if !found {
+			break
+		}
+		c.output("%s pages you: \"%s\"", speaker.Name, m.message)
+	case EventTypeSay:
+		if m.dst == inside {
+			speaker, found := c.db.Fetch(m.src)
+			if !found {
+				break
+			}
+			c.output("%s says \"%s\"", speaker.Name, m.message)
+		}
+	case EventTypePose:
+		if m.dst == inside {
+			if m.src == c.actor.ID {
+				c.output("%s %s", c.actor.Name, m.message)
+			} else {
+				speaker, found := c.db.Fetch(m.src)
+				if !found {
+					break
+				}
+				c.output("%s %s", speaker.Name, m.message)
+			}
+		}
+	case EventTypeForce:
+		actor, found := c.db.Fetch(m.dst)
+		if !found {
+			break
+		}
+		c.actor = actor
+		c.evaluateCommand(m)
+	case EventTypeCommand:
+		c.evaluateCommand(m)
+	}
+}
+
+func (c *ExecutionContext) evaluateCommand(m PlayerEvent) {
+	message := m.message
+	c.actor.Refresh()
+	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(m.connectionID)
+	case message == "WHO":
+		c.whoCmd()
+	case message == "HOWLONG":
+		time.Sleep(5 * time.Second)
+	case strings.HasPrefix(message, "@create "):
+		c.createCmd(strings.TrimPrefix(message, "@create "))
+	case strings.HasPrefix(message, "@dig "):
+		c.digCmd(message)
+	case strings.HasPrefix(message, "@open "):
+		c.openCmd(message)
+	case strings.HasPrefix(message, "@name "):
+		c.nameCmd(message)
+	case strings.HasPrefix(message, "@desc "):
+		c.descCmd(message)
+	case strings.HasPrefix(message, "@tel "):
+		c.telCmd(strings.TrimPrefix(message, "@tel "))
+	case strings.HasPrefix(message, "@dump "):
+		c.dumpCmd(strings.TrimPrefix(message, "@dump "))
+	case strings.HasPrefix(message, "@destroy "):
+		c.destroyCmd(strings.TrimPrefix(message, "@destroy "))
+	case strings.HasPrefix(message, "@force "):
+		c.forceCmd(message)
+	default:
+		if !c.goCmd(message) {
+			c.output("What?\n")
+		}
+	}
+
+}
+
+func (c *ExecutionContext) lookCmd(at string) {
+
+	roomID, found := c.db.GetParent(c.actor.ID)
+	room, found := c.db.Fetch(roomID)
+	if !found {
+		c.output("True Limbo (#NaN)\nThere's nothing to see here. You are inside an object that doesn't exist.")
+		return
+	}
+
+	if len(at) > 0 {
+		object, matchType := room.MatchLinkNames(at, c.actor.ID).ExactlyOne()
+		switch matchType {
+		case MatchOne:
+			c.output("%s\n%s", object.DetailedName(), object.Description)
+		case MatchNone:
+			c.output("I don't see that here.")
+		case MatchMany:
+			c.output("I don't now which one you're trying to look at.")
+		}
+	} else {
+		c.output("%s\n%s", room.DetailedName(), room.Description)
+		lookLinks := func(linkType string, pretty string) {
+			linknames := room.GetLinkNames(linkType, DBRefList{c.actor.ID})
+			if len(linknames) > 0 {
+				c.output("%s\n %s", pretty, strings.Join(linknames, "\n "))
+			}
+		}
+		lookLinks("thing", "Things:")
+		lookLinks("player", "Players:")
+		exits := room.GetLinkNames("exit", nil)
+		if len(exits) > 0 {
+			c.output("Exits:")
+			exitList := make([]string, 0)
+			for _, e := range exits {
+				aliases := strings.Split(e, ";")
+				exitList = append(exitList, aliases[0])
+			}
+			c.output(strings.Join(exitList, " "))
+		}
+	}
+
+}
+
+func (c *ExecutionContext) objectName(id DBRef) string {
+	o, found := c.db.Fetch(id)
+	if found {
+		return o.DetailedName()
+	} else {
+		return fmt.Sprintf("MISSING OBJECT (#%d)", id)
+	}
+}
+
+func (c *ExecutionContext) examineCmd(at string) {
+
+	roomID, found := c.db.GetParent(c.actor.ID)
+	room, found := c.db.Fetch(roomID)
+	if !found {
+		return
+	}
+
+	object, matchType := room.MatchLinkNames(at, c.actor.ID).ExactlyOne()
+
+	switch matchType {
+	case MatchOne:
+
+		objectParentID, _ := c.db.GetParent(object.ID)
+
+		c.output("%s", object.DetailedName())
+		c.output("ID: %d", object.ID)
+		c.output("Type: %s", object.Type)
+		c.output("@name: %s", object.Name)
+		c.output("@desc: %s", object.Description)
+		c.output("Inside: %s", c.objectName(objectParentID))
+		c.output("Next: %s", c.objectName(object.Next))
+		c.output("Owner: %s", c.objectName(object.Owner))
+
+		inventory := object.GetLinkNames("*", nil)
+		if len(inventory) > 0 {
+			c.output("Contents:\n %s", strings.Join(inventory, "\n "))
+		}
+	case MatchNone:
+		c.output("I don't see that here.")
+	case MatchMany:
+		c.output("I don't know which one you're trying to examine.")
+	}
+
+}
+
+func (c *ExecutionContext) forceCmd(input string) {
+
+	r, _ := regexp.Compile(`^@force\pZ+([^=]*[^=\pZ]{1})\pZ*=\pZ*(.*)\pZ*$`)
+	params := r.FindStringSubmatch(input)
+	if params == nil {
+		return
+	}
+
+	objectName, command := params[1], params[2]
+
+	roomID, found := c.db.GetParent(c.actor.ID)
+	room, found := c.db.Fetch(roomID)
+	if !found {
+		return
+	}
+
+	objectID, err := NewDBRefFromHashRef(objectName)
+	wizard := false
+	if err == nil {
+		object, found := c.db.Fetch(objectID)
+		if !found {
+			c.output("I can't force what doesn't exist.")
+		}
+		if object.Type == "thing" || (object.Type == "player" && wizard) {
+			c.outbound <- PlayerEvent{src: c.actor.ID, dst: object.ID, message: command, messageType: EventTypeForce}
+		} else {
+			c.output("Some things just can't be forced.")
+		}
+	} else {
+
+		object, matchType := room.MatchLinkNames(objectName, c.actor.ID).ExactlyOne()
+
+		switch matchType {
+		case MatchOne:
+			if object.Type == "thing" || (object.Type == "player" && wizard) {
+				c.outbound <- PlayerEvent{src: c.actor.ID, dst: object.ID, message: command, messageType: EventTypeForce}
+			} else {
+				c.output("Some things just can't be forced.")
+			}
+		case MatchNone:
+			c.output("I don't see that here.")
+		case MatchMany:
+			c.output("I don't know which one you're trying to examine.")
+		}
+	}
+}
+
+func (c *ExecutionContext) sayCmd(message string) {
+
+	inside, _ := c.db.GetParent(c.actor.ID)
+	c.output("You say \"%s\"", message)
+	c.outbound <- PlayerEvent{src: c.actor.ID, dst: inside, message: message, messageType: EventTypeSay}
+
+}
+
+func (c *ExecutionContext) poseCmd(message string) {
+
+	inside, _ := c.db.GetParent(c.actor.ID)
+	c.outbound <- PlayerEvent{src: c.actor.ID, dst: inside, message: message, messageType: EventTypePose}
+
+}
+
+func (c *ExecutionContext) inventoryCmd() {
+
+	inventory := c.actor.GetLinkNames("*", nil)
+
+	if len(inventory) > 0 {
+		c.output("Inventory:\n %s", strings.Join(inventory, "\n "))
+	} else {
+		c.output("You're not carrying anything.")
+	}
+
+}
+
+func (c *ExecutionContext) getCmd(message string) {
+
+	roomID, found := c.db.GetParent(c.actor.ID)
+	room, found := c.db.Fetch(roomID)
+	if !found {
+		return
+	}
+
+	object, matchType := room.MatchLinkNames(message, c.actor.ID).ExactlyOne()
+
+	switch matchType {
+	case MatchOne:
+		if object.ID == c.actor.ID {
+			c.output("You can't pick yourself up.")
+			return
+		}
+		err := c.actor.Contains(&object)
+		if err != nil {
+			return
+		}
+		//c.actor.Refresh()
+		c.output("You pick up %s.", object.Name)
+		c.pemit(object.ID, "%s picked you up.", c.actor.Name)
+		c.oemit(room.ID, "%s picks up %s.", c.actor.Name, object.Name)
+	case MatchNone:
+		c.output("I don't see that here.")
+	case MatchMany:
+		c.output("I don't know which one.")
+	}
+
+}
+
+func (c *ExecutionContext) dropCmd(message string) {
+
+	roomID, found := c.db.GetParent(c.actor.ID)
+	room, found := c.db.Fetch(roomID)
+	if !found {
+		return
+	}
+
+	object, matchType := c.actor.MatchLinkNames(message, c.actor.ID).ExactlyOne()
+
+	switch matchType {
+	case MatchOne:
+		err := room.Contains(&object)
+		if err != nil {
+			return
+		}
+		inside, _ := c.db.GetParent(c.actor.ID)
+		c.output("You drop %s.", object.Name)
+		c.pemit(object.ID, "%s drops you.", c.actor.Name)
+		c.oemit(inside, "%s drops %s.", c.actor.Name, object.Name)
+	case MatchNone:
+		c.output("You're not carrying that.")
+	case MatchMany:
+		c.output("I don't now which one.")
+	}
+
+}
+
+func (c *ExecutionContext) enterCmd(message string) {
+
+	roomID, found := c.db.GetParent(c.actor.ID)
+	room, found := c.db.Fetch(roomID)
+	if !found {
+		return
+	}
+
+	object, matchType := room.MatchLinkNames(message, c.actor.ID).ExactlyOne()
+
+	switch matchType {
+	case MatchOne:
+		if object.ID == c.actor.ID {
+			c.output("Entering yourself would be a bad idea.")
+			return
+		}
+		err := object.Contains(&c.actor)
+		if err != nil {
+			return
+		}
+		c.output("You climb into %s.", object.Name)
+		c.oemit(room.ID, "%s climbs into %s.", c.actor.Name, object.Name)
+		c.oemit(object.ID, "%s squeezes into %s with you.", c.actor.Name, object.Name)
+	case MatchNone:
+		c.output("I don't see that here.")
+	case MatchMany:
+		c.output("I don't now which one.")
+	}
+}
+
+func (c *ExecutionContext) leaveCmd() {
+
+	inside, _ := c.db.GetParent(c.actor.ID)
+	object, found := c.db.Fetch(inside)
+	if !found {
+		return
+	}
+	objectInside, _ := c.db.GetParent(inside)
+	if objectInside == 0 { // probably trying to 'leave' a room
+		c.output("You can't leave here.")
+		return
+	}
+
+	room, found := c.db.Fetch(objectInside)
+	if !found {
+		return
+	}
+
+	err := room.Contains(&c.actor)
+	if err != nil {
+		return
+	}
+
+	//c.actor.Refresh()
+
+	c.output("You climb out of %s.", object.Name)
+	c.oemit(object.ID, "%s climbs out of %s.", c.actor.Name, object.Name)
+	c.oemit(room.ID, "%s climbs out of %s.", c.actor.Name, object.Name)
+
+}
+
+func (c *ExecutionContext) quitCmd(connectionID int) {
+
+	c.output("So long, it's been good to know yah.")
+	c.outbound <- PlayerEvent{src: c.actor.ID, dst: c.actor.ID, messageType: EventTypeQuit, connectionID: connectionID}
+
+}
+
+func (c *ExecutionContext) whoCmd() {
+	//	onlinePlayers := c.eventDistributor.OnlinePlayers()
+
+	c.output("Currently Online:\n")
+
+	//for _, ref := range onlinePlayers {
+	//	c.output("%s\n", c.db.GetName(ref))
+	//}
+}
+
+func (c *ExecutionContext) createCmd(message string) {
+
+	roomID, found := c.db.GetParent(c.actor.ID)
+	room, found := c.db.Fetch(roomID)
+	if !found {
+		return
+	}
+
+	o := c.factory.NewThing()
+	o.Name = strings.TrimSpace(message)
+	o.Owner = c.actor.ID
+	o.Commit()
+
+	err := room.Contains(&o)
+	if err != nil {
+		return
+	}
+
+	c.oemit(room.ID, "A %s appears out of the ether.", o.Name)
+	c.output("%s Created.", o.DetailedName())
+
+}
+
+func (c *ExecutionContext) openCmd(input string) {
+	// @open <in1;in2;in3;etc>=#<room>,<out1;out2;out3;etc>
+
+	r, _ := regexp.Compile(`^@open\pZ+([^=]*[^=\pZ]+)\pZ*=#([0-9]+)(?:\pZ*,\pZ*([^,]*[^,\pZ]+)\pZ*)?`)
+	params := r.FindStringSubmatch(input)
+
+	if params == nil {
+		return
+	}
+
+	inExit, roomIDStr, outExit := params[1], params[2], params[3]
+
+	if len(inExit) == 0 || len(roomIDStr) == 0 {
+		c.output("Bad command or file name.")
+		return
+	}
+
+	targetID, _ := NewDBRefFromString(roomIDStr) // this will never fail, the regexp guarantees that
+	targetRoom, found := c.db.Fetch(targetID)
+	if !found {
+		c.output("Target not found.")
+		return
+	}
+
+	roomID, found := c.db.GetParent(c.actor.ID)
+	room, found := c.db.Fetch(roomID)
+	if !found {
+		return
+	}
+
+	toExit := c.factory.NewExit(inExit, targetRoom.ID, c.actor.ID)
+	toExit.Commit()
+	err := room.Contains(&toExit)
+	if err != nil {
+		return
+	}
+	c.output("%s Created.", toExit.DetailedName())
+
+	if len(outExit) > 0 {
+		fromExit := c.factory.NewExit(outExit, room.ID, c.actor.ID)
+		fromExit.Commit()
+		err = targetRoom.Contains(&fromExit)
+		if err != nil {
+			return
+		}
+		c.output("%s Created.", fromExit.DetailedName())
+	}
+
+}
+
+func (c *ExecutionContext) digCmd(input string) {
+	// @dig <Room name>=<in1;in2;in3;etc>,<out1;out2;out3;etc>
+	//@dig foo bar  = <F>oo;foo;f,<B>ack;back;b
+
+	r, _ := regexp.Compile(`^@dig\pZ+([^=]*[^=\pZ]+)(\pZ*=\pZ*(?:([^,]*[^,\pZ]+)\pZ*)?(?:\pZ*,\pZ*([^,]*[^,\pZ]+)\pZ*)?)?`)
+	params := r.FindStringSubmatch(input)
+	if params == nil {
+		return
+	}
+
+	roomName, inExit, outExit := params[1], params[2], params[3]
+
+	if len(roomName) == 0 {
+		c.output("Rooms can't not have names.")
+		return
+	}
+
+	newRoom := c.factory.NewRoom()
+	newRoom.Name = roomName
+	newRoom.Owner = c.actor.ID
+	newRoom.Commit()
+
+	c.output("%s Created.", newRoom.DetailedName())
+
+	if len(inExit) > 0 || len(outExit) > 0 {
+		roomID, found := c.db.GetParent(c.actor.ID)
+		room, found := c.db.Fetch(roomID)
+		if !found {
+			return
+		}
+		if len(inExit) > 0 {
+			toExit := c.factory.NewExit(inExit, newRoom.ID, c.actor.ID)
+			toExit.Commit()
+			err := room.Contains(&toExit)
+			if err != nil {
+				return
+			}
+			c.output("%s Created.", toExit.DetailedName())
+		}
+		if len(outExit) > 0 {
+			fromExit := c.factory.NewExit(outExit, room.ID, c.actor.ID)
+			fromExit.Commit()
+			err := newRoom.Contains(&fromExit)
+			if err != nil {
+				return
+			}
+			c.output("%s Created.", fromExit.DetailedName())
+		}
+	}
+
+}
+
+func (c *ExecutionContext) nameCmd(input string) {
+
+	r, _ := regexp.Compile(`^@name\pZ+([^=]*[^=\pZ]{1})\pZ*=\pZ*(.*)\pZ*$`)
+	params := r.FindStringSubmatch(input)
+	if params == nil {
+		return
+	}
+
+	objectName, name := params[1], params[2]
+
+	roomID, found := c.db.GetParent(c.actor.ID)
+	room, found := c.db.Fetch(roomID)
+	if !found {
+		return
+	}
+
+	candidate, matchType := room.MatchLinkNames(objectName, c.actor.ID).ExactlyOne()
+	switch matchType {
+	case MatchOne:
+		candidate.Name = name
+		candidate.Commit()
+		c.output("Name set.")
+		//c.actor.Refresh()
+	case MatchNone:
+		c.output("I don't see that here.")
+	case MatchMany:
+		c.output("I don't now which one.")
+	}
+
+}
+
+func (c *ExecutionContext) descCmd(input string) {
+
+	r, _ := regexp.Compile(`^@desc\pZ+([^=]*[^=\pZ]{1})\pZ*=\pZ*(.*)\pZ*$`)
+	params := r.FindStringSubmatch(input)
+	if params == nil {
+		return
+	}
+
+	objectName, description := params[1], params[2]
+
+	roomID, found := c.db.GetParent(c.actor.ID)
+	room, found := c.db.Fetch(roomID)
+
+	if !found {
+		return
+	}
+
+	var editObject *Object
+	switch objectName {
+	case "here":
+		editObject = &room
+	case "me":
+		editObject = &c.actor
+	default:
+		candidate, matchType := room.MatchLinkNames(objectName, c.actor.ID).ExactlyOne()
+		switch matchType {
+		case MatchOne:
+			editObject = &candidate
+		case MatchNone:
+			c.output("I don't see that here.")
+			return
+		case MatchMany:
+			c.output("I don't now which one.")
+			return
+		}
+	}
+
+	editObject.Description = description
+	editObject.Commit()
+	//c.actor.Refresh()
+	c.output("Description set.")
+
+}
+
+func (c *ExecutionContext) telCmd(destStr string) {
+
+	dest, err := NewDBRefFromHashRef(destStr)
+
+	if err != nil {
+		c.output("That doesn't look like a DBRef.")
+		return
+	}
+
+	newRoom, found := c.db.Fetch(dest)
+	if !found {
+		c.output("That doesn't exist.")
+		return
+	}
+
+	c.output("You feel an intense wooshing sensation.")
+	err = newRoom.Contains(&c.actor)
+	if err != nil {
+		return
+	}
+
+	c.actor.Refresh()
+	c.lookCmd("")
+
+}
+
+func (c *ExecutionContext) dumpCmd(refStr string) {
+
+	ref, err := NewDBRefFromHashRef(refStr)
+
+	if err != nil {
+		c.output("That doesn't look like a DBRef.")
+		return
+	}
+
+	obj, found := c.db.Fetch(ref)
+	if !found {
+		c.output("That doesn't exist.")
+		return
+	}
+
+	c.output("%s", c.db.DumpObject(obj.ID))
+
+}
+
+func (c *ExecutionContext) destroyCmd(message string) {
+
+	roomID, found := c.db.GetParent(c.actor.ID)
+	room, found := c.db.Fetch(roomID)
+	if !found {
+		return
+	}
+
+	object, matchType := room.MatchLinkNames(message, c.actor.ID).ExactlyOne()
+
+	switch matchType {
+	case MatchOne:
+		if object.ID == c.actor.ID {
+			c.output("There are alternatives to suicide.")
+			return
+		}
+		if object.Type == "player" {
+			c.output("I didn't think homicide was your thing.")
+			return
+		}
+		name := object.DetailedName()
+		err := object.Delete()
+		if err == nil {
+			//c.actor.Refresh()
+			c.output("%s vanishes into thin air.", name)
+		}
+	case MatchNone:
+		c.output("I don't see that here.")
+	case MatchMany:
+		c.output("I don't know which one.")
+	}
+
+}
+
+func (c *ExecutionContext) goCmd(dir string) bool {
+
+	roomID, found := c.db.GetParent(c.actor.ID)
+	room, found := c.db.Fetch(roomID)
+	if !found {
+		return false
+	}
+
+	exit, matchType := room.MatchExitNames(dir).ExactlyOne()
+	switch matchType {
+	case MatchOne:
+		if exit.Next.Valid() {
+			newRoom, found := c.db.Fetch(exit.Next)
+			if !found {
+				c.output("That exit appears to be broken!")
+				return true
+			}
+			err := newRoom.Contains(&c.actor)
+			if err != nil {
+				return false
+			}
+			//c.actor.Refresh()
+			c.output("You head towards %s.", newRoom.Name)
+			c.oemit(room.ID, "%s leaves the room.", c.actor.Name)
+			c.oemit(newRoom.ID, "%s enters the room.", c.actor.Name)
+			return true
+		}
+	case MatchNone:
+		return false
+	case MatchMany:
+		c.output("Ambiguous exit names are ambiguous.")
+		return true
+	}
+
+	return false
+
+}
+
+func (c *ExecutionContext) oemit(audience DBRef, format string, a ...interface{}) {
+
+	message := fmt.Sprintf(format, a...)
+	c.outbound <- PlayerEvent{src: c.actor.ID, dst: audience, message: message, messageType: EventTypeOEmit}
+
+}
+
+func (c *ExecutionContext) output(format string, a ...interface{}) {
+
+	message := fmt.Sprintf(format, a...)
+	if !c.forceContext {
+		c.outbound <- PlayerEvent{src: c.actor.ID, dst: c.actor.ID, message: message, messageType: EventTypeOutput}
+	}
+}
+
+func (c *ExecutionContext) pemit(target DBRef, format string, a ...interface{}) {
+
+	message := fmt.Sprintf(format, a...)
+	c.outbound <- PlayerEvent{src: c.actor.ID, dst: target, message: message, messageType: EventTypePEmit}
+
+}
+
+func (c *ExecutionContext) emit(audience DBRef, format string, a ...interface{}) {
+
+	message := fmt.Sprintf(format, a...)
+	c.outbound <- PlayerEvent{src: c.actor.ID, dst: audience, message: message, messageType: EventTypeEmit}
+
+}

object.go

@@ -99,11 +99,11 @@ func (o *Object) Contains(c *Object) error {
 	return o.db.Link(o.ID, c.ID, c.Type)
 }
 
-func (o *Object) MatchLinkNames(matchName string, player DBRef, excludePlayer bool) ObjectList {
+func (o *Object) MatchLinkNames(matchName string, player DBRef) ObjectList {
 	if matchName == "here" {
 		return ObjectList{*o}
 	}
-	if !excludePlayer && matchName == "me" {
+	if matchName == "me" {
 		p, found := o.db.Fetch(player)
 		if !found {
 			return ObjectList{}
@@ -116,9 +116,6 @@ func (o *Object) MatchLinkNames(matchName string, player DBRef, excludePlayer bo
 	children := o.db.GetChildren(o.ID) // map[DBRef]string
 
 	for childID, _ := range children {
-		if excludePlayer && player == childID {
-			continue
-		}
 		o, found := o.db.Fetch(childID)
 		if found {
 			idName := fmt.Sprintf("#%d", o.ID)
@@ -182,6 +179,7 @@ func (o *Object) GetLinkNames(matchType string, exclude DBRefList) []string {
 		skip := false
 		for _, excludeID := range exclude {
 			if excludeID == childID {
+				fmt.Println("Skipping ", childID)
 				skip = true
 			}
 		}