go fmt

client.go

 				c.write("Bad username or password.\n")
 				break
 			}
-			
 
 			c.playerID = player.ID
 			c.authenticated = true
 				c.write("That name is already taken.\n")
 				break
 			}
-			
+
 			playerID, _ := c.db.CreatePlayer(strings.TrimSpace(fields[1]), strings.TrimSpace(fields[2]), nil)
-			
+
 			_, found = c.db.Fetch(playerID)
 			if !found {
 				c.write("I can't even.\n")
 				break
 			}
-			
+
 			c.write("You have been created. Now you can connect!\n")
-			
+
 		} else {
 			c.write("What?\n")
 		}

cmd/funmow/main.go

 package main
 
 import (
+	"flag"
 	"github.com/naleek/funmow"
 	"log"
 	"net"
-	"flag"
 )
 
 const (
-	FunMOWVersion   = "0.2"
-	FunMOWDefaultDB = "funmow.db"
-	FunMOWDefaultListen    = ":4201"
+	FunMOWVersion       = "0.2"
+	FunMOWDefaultDB     = "funmow.db"
+	FunMOWDefaultListen = ":4201"
 )
 
 func main() {
 		return
 	}
 
-
-
 	log.Print("Starting FunMOW Version ", FunMOWVersion)
 
 	log.Print("Using database ", FunMOWDefaultDB)
 
 	f := funmow.NewObjectFactory(db)
 
-	keelan, _ := db.CreatePlayer("keelan", "123", map[string]bool{"wizard":true})
+	keelan, _ := db.CreatePlayer("keelan", "123", map[string]bool{"wizard": true})
 	dan, _ := db.CreatePlayer("dan", "123", nil)
 
 	outside := f.NewObject()

db.go

 	"bytes"
 	"encoding/binary"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"github.com/boltdb/bolt"
-	"strconv"
-	"errors"
 	"regexp"
+	"strconv"
 )
 
 const (
 
 func NewDBRefFromHashRef(v string) (DBRef, bool) {
 	var destInt int
-	
+
 	if matched, _ := regexp.MatchString(`^\pZ*#[0-9]+\pZ*?`, v); !matched {
 		return 0, false
 	}
 func (s *DB) SetPlayer(name string, player PlayerMeta) error {
 
 	err := s.db.Update(func(tx *bolt.Tx) error {
-		
+
 		buf, err := json.Marshal(player)
 
-		if err != nil { return err }
-	
+		if err != nil {
+			return err
+		}
+
 		b := tx.Bucket([]byte("player"))
-		
+
 		return b.Put([]byte(name), buf)
 	})
 
 func (s *DB) GetPlayer(name string) (PlayerMeta, bool) {
 	var player PlayerMeta
 	found := false
-	
+
 	s.db.View(func(tx *bolt.Tx) error {
 		b := tx.Bucket([]byte("player"))
 		v := b.Get([]byte(name))
-		if v == nil { return nil }
+		if v == nil {
+			return nil
+		}
 		err := json.Unmarshal(v, &player)
 		if err == nil {
 			found = true
 			return errors.New("Can't find player")
 		}
 		err := playerBucket.Delete([]byte(oldName))
-		if err != nil { return err }
+		if err != nil {
+			return err
+		}
 		return playerBucket.Put([]byte(newName), buf)
 	})
 }
 
-
 func (s *DB) CreatePlayer(name string, password string, flags map[string]bool) (DBRef, error) {
 
 	var playerID DBRef

execution_context.go

 	if !found {
 		return nil
 	}
-	
-	
 
 	c.actor = actor
 	c.outbound = outbound
 	if found {
 		c.context, _ = c.db.Fetch(contextID)
 	}
-	
-	
+
 	switch m.messageType {
 	case EventTypeLogin:
 		if c.actor.Type == "player" {
 		c.destroyCmd(strings.TrimPrefix(message, "@destroy "))
 	case strings.HasPrefix(message, "@force "):
 		c.forceCmd(message)
-	
-		
+
 	default:
 		if !c.goCmd(message) {
 			c.output("What?\n")
 
 	if len(target) > 0 {
 		object, found := c.MatchFirst(c.context.ID, target, false, false)
-		if (!found) {
+		if !found {
 			c.output("I don't see that here.")
 			return
 		}
 		c.output("%s\n%s", c.context.DetailedName(), c.context.Description)
 		contents := c.context.GetContents(c.actor.ID)
 		if len(contents) > 0 {
-			c.output("Contents:\n"+strings.Join(contents,"\n"))
+			c.output("Contents:\n" + strings.Join(contents, "\n"))
 		}
 		exits := c.context.GetExits()
 		if len(exits) > 0 {
-			c.output("Obvious Exits:\n"+strings.Join(exits," "))
+			c.output("Obvious Exits:\n" + strings.Join(exits, " "))
 		}
 	}
 
 func (c *ExecutionContext) examineCmd(objectName string) {
 
 	object, found := c.MatchFirst(c.context.ID, objectName, true, true)
-	if (!found) {
+	if !found {
 		c.output("I don't see that here.")
 		return
 	}
-	
+
 	c.output("%s", object.DetailedName())
 	c.output("ID: %d", object.ID)
 	c.output("Type: %s", object.Type)
 	if len(contents) > 0 {
 		c.output("Contents:\n %s", strings.Join(contents, "\n "))
 	}
-	
+
 	exits := object.GetExits()
 	if len(exits) > 0 {
 		c.output("Exits:\n %s", strings.Join(exits, "\n "))
 	}
-	
-	
-   
-    flags := make([]string, 0, len(object.Flags))
-    for k, v := range object.Flags {
-        if v {
-        	flags = append(flags, k)
-        }
-    }
-    c.output("Flags:\n%s", strings.Join(flags, ", "))
-    
-    properties := make([]string, 0, len(object.Properties))
-    for k, v := range object.Properties {
-        properties = append(properties, fmt.Sprintf("%s: \"%s\"", k, v))
-    }
-    c.output("Properties:\n%s", strings.Join(properties, ", "))
 
-}
+	flags := make([]string, 0, len(object.Flags))
+	for k, v := range object.Flags {
+		if v {
+			flags = append(flags, k)
+		}
+	}
+	c.output("Flags:\n%s", strings.Join(flags, ", "))
 
+	properties := make([]string, 0, len(object.Properties))
+	for k, v := range object.Properties {
+		properties = append(properties, fmt.Sprintf("%s: \"%s\"", k, v))
+	}
+	c.output("Properties:\n%s", strings.Join(properties, ", "))
 
+}
 
 func (c *ExecutionContext) forceCmd(input string) {
 
 	wizard := c.actor.GetFlag("wizard")
 
 	object, found := c.MatchFirst(c.context.ID, objectName, true, false)
-	if (!found) {
+	if !found {
 		c.output("I don't see that here.")
 		return
 	}
 	if object.Type == "player" && !wizard {
 		c.output("It's not nice to force others to do your bidding.")
 		return
-	} 
+	}
 	if object.Owner != c.actor.ID && !wizard {
 		c.output("It's not nice to touch other people's things.")
 		return
-	} 
+	}
 	c.outbound <- PlayerEvent{src: c.actor.ID, dst: object.ID, message: command, messageType: EventTypeForce}
 
 }
 }
 
 func (c *ExecutionContext) getCmd(objectName string) {
-	
+
 	object, found := c.MatchFirst(c.context.ID, objectName, false, false)
-	if (!found) {
+	if !found {
 		c.output("I don't see that here.")
 		return
 	}
-	
+
 	if object.ID == c.actor.ID {
 		c.output("You can't pick yourself up.")
 		return
 	c.pemit(object.ID, "%s picked you up.", c.actor.Name)
 	c.oemit(c.context.ID, "%s picks up %s.", c.actor.Name, object.Name)
 
-
 }
 
 func (c *ExecutionContext) putCmd(input string) {
 	c.xferCmd(input, "give", "to")
 }
 
-
 func (c *ExecutionContext) xferCmd(input string, verb string, preposition string) {
 
-	r, _ := regexp.Compile(`^`+verb+`\pZ+([^=]*[^=\pZ]{1})\pZ*`+preposition+`\pZ*(.*)\pZ*$`)
+	r, _ := regexp.Compile(`^` + verb + `\pZ+([^=]*[^=\pZ]{1})\pZ*` + preposition + `\pZ*(.*)\pZ*$`)
 
 	params := r.FindStringSubmatch(input)
 	if params == nil {
 	objectName, receiverName := params[1], params[2]
 
 	object, found := c.MatchFirst(c.actor.ID, objectName, false, false)
-	if (!found) {
-		c.output("You can't "+verb+" what you don't have.")
+	if !found {
+		c.output("You can't " + verb + " what you don't have.")
 		return
 	}
 	receiver, found := c.MatchFirst(c.context.ID, receiverName, false, false)
-	if (!found) {
-		c.output("I cant find who or what you want to "+verb+" this "+preposition+".")
+	if !found {
+		c.output("I cant find who or what you want to " + verb + " this " + preposition + ".")
 		return
 	}
 
 	if err != nil {
 		return
 	}
-	
+
 	c.output("You "+verb+" %s "+preposition+" %s.", object.Name, receiver.Name)
 	c.pemit(object.ID, "%s "+verb+"s you "+preposition+" %s.", c.actor.Name, receiver.Name)
-	
-	if (verb == "give") {
+
+	if verb == "give" {
 		c.pemit(receiver.ID, "%s gives you %s.", c.actor.Name, object.Name)
 	} else {
 		c.pemit(receiver.ID, "%s puts %s into you.", c.actor.Name, object.Name)
 	}
-	
+
 }
 
 func (c *ExecutionContext) MatchFirst(context DBRef, matchName string, globalDBRefMatch bool, playerNameMatch bool) (Object, bool) {
 	}
 	if matchName == "me" {
 		return c.actor, true
-	}	
-		
+	}
+
 	if globalDBRefMatch {
 		ref, valid := NewDBRefFromHashRef(matchName)
 		if valid {
 			}
 		}
 	}
-	
+
 	if playerNameMatch {
 		playerMeta, foundMeta := c.db.GetPlayer(matchName)
 		if foundMeta {
 		}
 	}
 	return Object{}, false
-	
+
 }
 
 func (c *ExecutionContext) dropCmd(objectName string) {
 
 	object, found := c.MatchFirst(c.actor.ID, objectName, false, false)
-	if (!found) {
+	if !found {
 		c.output("You're not carrying that.")
 		return
 	}
-	
+
 	err := c.context.Contains(&object)
 	if err != nil {
 		return
 func (c *ExecutionContext) enterCmd(objectName string) {
 
 	object, found := c.MatchFirst(c.context.ID, objectName, false, false)
-	if (!found) {
+	if !found {
 		c.output("I don't see that here.")
 		return
 	}
-	
+
 	if object.Type == "player" {
 		c.output("Maybe you should seek consent prior to entering another player.")
 		return
 		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(c.context.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)
-	
+
 }
 
 func (c *ExecutionContext) leaveCmd() {
 	}
 
 	container, found := c.db.Fetch(outerObjectID)
-	if !found { return }
+	if !found {
+		return
+	}
 
 	err := container.Contains(&c.actor)
-	if err != nil { return }
+	if err != nil {
+		return
+	}
 
 	c.output("You climb out of %s.", c.context.Name)
 	c.oemit(c.context.ID, "%s climbs out of %s.", c.actor.Name, c.context.Name)
 
 }
 
-
 func (c *ExecutionContext) nameCmd(input string) {
 
 	r, _ := regexp.Compile(`^@name\pZ+([^=]*[^=\pZ]{1})\pZ*=\pZ*(.*)\pZ*$`)
 
 }
 
-
-
 func (c *ExecutionContext) setCmd(input string) {
 	r, _ := regexp.Compile(`^@set\pZ+([^=]*[^=\pZ]{1})\pZ*=\pZ*(!)?(.*)\pZ*$`)
 	params := r.FindStringSubmatch(input)
 		return
 	}
 
-	objectName, value, flag := params[1], params[2]!="!", params[3]
+	objectName, value, flag := params[1], params[2] != "!", params[3]
 
 	object, found := c.MatchFirst(c.context.ID, objectName, true, true)
-	if (!found) {
+	if !found {
 		c.output("I don't know what that is")
 		return
 	}
-	
-		
+
 	object.SetFlag(flag, value)
 	object.Commit()
-	
+
 	c.output("It is so.")
-	
+
 }
 
 func (c *ExecutionContext) descCmd(input string) {
 
 	var dest Object
 	var found bool
-	
+
 	dest, found = c.MatchFirst(c.context.ID, destStr, true, false)
-	
+
 	if !found {
 		c.output("Invalid destination.")
 		return
 	}
-	
+
 	if dest.Type == "exit" {
 		c.output("As fun is it sounds, you're not going to teleport into an exit.")
 		return
 	}
-	
+
 	if dest.Type == "player" {
 		c.output("Teleporting into players is very impolite.")
 		return
 	if dest.Owner != c.actor.ID && !dest.GetFlag("jump_ok") {
 		c.output("You're not allowed to do that.")
 	}
-	
+
 	c.output("You feel an intense wooshing sensation.")
 	c.oemit(c.context.ID, "%s teleports out of the room.", c.actor.Name)
 	c.oemit(dest.ID, "%s teleports in to the room.", c.actor.Name)
 	if err != nil {
 		return
 	}
-	
 
 	c.actor.Refresh()
 	c.lookCmd("")
 func (c *ExecutionContext) destroyCmd(target string) {
 
 	object, found := c.MatchFirst(c.actor.ID, target, true, false)
-	if (!found) {
+	if !found {
 		c.output("I don't see that here.")
 		return
 	}
-	
+
 	if object.ID == c.actor.ID {
 		c.output("There are alternatives to suicide.")
 		return

object.go

 )
 
 type PlayerMeta struct {
-	ID          DBRef  `json:"id"`
-	Password    string `json:"password"`
+	ID       DBRef  `json:"id"`
+	Password string `json:"password"`
 }
 
 type Object struct {
-
 	ID          DBRef             `json:"id"`
 	Type        string            `json:"type"`
 	Owner       DBRef             `json:"owner"`
 	Next        DBRef             `json:"next"`
 	Name        string            `json:"name"`
 	Description string            `json:"description"`
-	Flags		map[string]bool   `json:"flags"`
+	Flags       map[string]bool   `json:"flags"`
 	Properties  map[string]string `json:"properties"`
-	
-	db    *DB
-	
+
+	db *DB
 }
 
 type ObjectFactory struct {
 	r := make([]string, 0)
 	children := o.db.GetChildren(o.ID)
 	for childID, linkType := range children {
-		if childID == exclude { continue }
-		if !(linkType == "player" || linkType == "thing") { continue }
+		if childID == exclude {
+			continue
+		}
+		if !(linkType == "player" || linkType == "thing") {
+			continue
+		}
 		o, found := o.db.Fetch(childID)
-		if !found { continue }
-		if linkType == "player" && !o.GetFlag("online") { continue }
+		if !found {
+			continue
+		}
+		if linkType == "player" && !o.GetFlag("online") {
+			continue
+		}
 		r = append(r, o.DetailedName())
 	}
 	sort.Strings(r)
 	r := make([]string, 0)
 	children := o.db.GetChildren(o.ID)
 	for exitID, linkType := range children {
-		if linkType != "exit" { continue }
+		if linkType != "exit" {
+			continue
+		}
 		exit, found := o.db.Fetch(exitID)
-		if !found { continue }
+		if !found {
+			continue
+		}
 		aliases := strings.Split(exit.Name, ";")
 		r = append(r, aliases[0])
 	}
-	
+
 	sort.Strings(r)
 	return r
 }
 	if o.Flags == nil {
 		o.Flags = make(map[string]bool)
 	}
-	o.Flags[flag]=value
+	o.Flags[flag] = value
 }
 
 func (o *Object) GetFlag(flag string) bool {
-	
-	if o.Flags == nil { return false }
+
+	if o.Flags == nil {
+		return false
+	}
 	value, ok := o.Flags[flag]
-	if !ok { return false }
-	
+	if !ok {
+		return false
+	}
+
 	return value
 }
 
 	if o.Properties == nil {
 		o.Properties = make(map[string]string)
 	}
-	o.Properties[key]=value
+	o.Properties[key] = value
 }
 
 func (o *Object) GetProp(key string) string {
-	
-	if o.Properties == nil { return "" }
+
+	if o.Properties == nil {
+		return ""
+	}
 	value, ok := o.Properties[key]
-	if !ok { return "" }
-	
+	if !ok {
+		return ""
+	}
+
 	return value
 }
 
-
-
-
 type ObjectList []Object
 
 func (l ObjectList) First() Object {