Shuffled event buffer around, look after go.

client.go

 import (
 	"bufio"
 	"fmt"
+	"github.com/mgutz/ansi"
 	"log"
 	"net"
 	"strings"
 	"unicode"
-	"github.com/mgutz/ansi"
 )
 
 type Client struct {
 
 func (c *Client) splash() {
 
-	c.write(ansi.Color("Welcome to...","red+b")+"\n")
+	c.write(ansi.Color("Welcome to...", "red+b") + "\n")
 	c.write("  ___                __  __    ___  __      __\n")
 	c.write(" | __| _  _   _ _   |  \\/  |  / _ \\ \\ \\    / /\n")
 	c.write(" | _| | || | | ' \\  | |\\/| | | (_) | \\ \\/\\/ /\n")
 	c.write(" |_|   \\_,_| |_||_| |_|  |_|  \\___/   \\_/\\_/\n\n")
 	c.write("Commands:\n")
-	c.write("To create a player: "+ansi.Color("create <username> <password>","blue+b")+"\n")
-	c.write("To connect: "+ansi.Color("connect <username> <password>","blue+b")+"\n")
+	c.write("To create a player: " + ansi.Color("create <username> <password>", "blue+b") + "\n")
+	c.write("To connect: " + ansi.Color("connect <username> <password>", "blue+b") + "\n")
 
 }
 

event_buffer.go

+package funmow
+
+func EventBuffer(inbound chan PlayerEvent) chan PlayerEvent {
+
+	queue := make([]*PlayerEvent, 0)
+	inboundBuffer := make(chan PlayerEvent)
+
+	go func() {
+		running := true
+	bufferLoop:
+		for running {
+			if len(queue) == 0 {
+				select {
+				case newEvent, ok := <-inbound:
+					if !ok {
+						break bufferLoop
+					}
+					queue = append(queue, &newEvent)
+				}
+			} else {
+				event := queue[0]
+				select {
+				case newEvent, ok := <-inbound:
+					if !ok {
+						break bufferLoop
+					}
+					queue = append(queue, &newEvent)
+				case inboundBuffer <- *event:
+					queue = queue[1:]
+				}
+			}
+		}
+		close(inboundBuffer)
+	}()
+
+	return inboundBuffer
+
+}

event_distributor.go

 	e.whoChan <- replyChan
 	onlinePlayers := <-replyChan
 	return onlinePlayers
-	return DBRefList{}
 }
 
 //[client runs quit command]
 	e.players = make(map[DBRef]*playerRegistration)
 
 	outbound := make(chan PlayerEvent)
+	outboundBuffered := EventBuffer(outbound)
 
 	forceContext := NewForceContext(e, e.db, outbound)
 	forceInbound := forceContext.StartInboundChannel()
 
 		select {
 		case replyChan := <-e.whoChan:
- 			onlinePlayers := make(DBRefList, 0)
- 			for playerID, _ := range e.players {
- 				onlinePlayers = append(onlinePlayers, playerID)
- 			}
- 			replyChan <- onlinePlayers
+			onlinePlayers := make(DBRefList, 0)
+			for playerID, _ := range e.players {
+				onlinePlayers = append(onlinePlayers, playerID)
+			}
+			replyChan <- onlinePlayers
 		case sub := <-e.subscribeChan:
 
 			if _, exists := e.players[sub.playerID]; !exists {
 			reg := e.players[sub.playerID]
 			reg.connInbound[sub.connectionID] = sub.inbound
 			sub.outbound <- outbound
-		case event := <-outbound: // message
+		case event := <-outboundBuffered: // message
 			//fmt.Printf("received message src:%d dest:%d type: %d\n", event.src, event.dst, event.messageType)
 
 			destPlayer, validDest := e.players[event.dst]

execution_context.go

 func (c *ExecutionContext) StartInboundChannel() chan PlayerEvent {
 	c.inbound = make(chan PlayerEvent)
 	inboundBuffer := make(chan PlayerEvent)
-	c.outbound = c.outbound
 
 	go func() {
 
 		c.evaluateCommand(m)
 		return
 	}
-	
+
 	c.actor.Refresh()
 	contextID, found := c.db.GetParent(c.actor.ID)
 	if found {
 	c.output("You head towards %s.", newRoom.DetailedName())
 	c.oemit(c.context.ID, "%s leaves the room.", c.actor.ColorName())
 	c.oemit(newRoom.ID, "%s enters the room.", c.actor.ColorName())
+	c.command("look")
 	return true
-
-	return false
-
 }
 
 func (c *ExecutionContext) command(format string, a ...interface{}) {