Cleaned up object resolution, cleaned up lots of stuff. Changed flages to be strictly booleans and added properties. Added 'give x to y' and 'put x into y' commands.

client.go

 		}
 	case "create":
 		if len(fields) == 3 {
-			player, found := c.db.GetPlayer(fields[1])
-			if !found || (found && player.Password != fields[2]) {
-				c.write("Bad username or password.\n")
+			_, found := c.db.GetPlayer(fields[1])
+			if found {
+				c.write("That name is already taken.\n")
 				break
 			}
 			
-			c.playerID = player.ID
-			c.authenticated = true
-
-			// when a player authenticates, the ipc channels get turned on
-			subReq := EventSubscribeRequest{
-				connectionID: c.connectionID,
-				playerID:     c.playerID,
-				inbound:      c.inbound,
-				outbound:     make(chan chan PlayerEvent),
+			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.outbound = c.eventDistributor.Subscribe(subReq)
-			c.sendCommand("look")
+			
+			c.write("You have been created. Now you can connect!\n")
+			
 		} else {
 			c.write("What?\n")
 		}

cmd/funmow/main.go

 	"github.com/naleek/funmow"
 	"log"
 	"net"
+	"flag"
 )
 
 const (
 	FunMOWVersion   = "0.2"
 	FunMOWDefaultDB = "funmow.db"
-	FunMOWListen    = ":4201"
+	FunMOWDefaultListen    = ":4201"
 )
 
 func main() {
 
+	var seed bool
+	var listen string
+	var dbPath string
+
+	flag.BoolVar(&seed, "seed", false, "Seed the world DB")
+	flag.StringVar(&listen, "listen", FunMOWDefaultListen, "Listen Address:Port of game server.")
+	flag.StringVar(&dbPath, "db", FunMOWDefaultDB, "Path to FunMOW database.")
+
+	help := flag.Bool("h", false, "Show usage")
+
+	flag.Parse()
+
+	if *help {
+		flag.PrintDefaults()
+		return
+	}
+
+
+
 	log.Print("Starting FunMOW Version ", FunMOWVersion)
 
 	log.Print("Using database ", FunMOWDefaultDB)
 
 	defer db.Close()
 
-	seedDB(db)
+	if seed {
+		log.Print("Seeding database...")
+		seedDB(db)
+	}
 
-	log.Print("Listening for connections on ", FunMOWListen)
-	ln, err := net.Listen("tcp", FunMOWListen)
+	log.Print("Listening for connections on ", listen)
+	ln, err := net.Listen("tcp", listen)
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	f := funmow.NewObjectFactory(db)
 
-	keelan, _ := db.CreatePlayer("keelan", map[string]string{"wizard":"true"})
-	dan, _ := db.CreatePlayer("dan", nil)
+	keelan, _ := db.CreatePlayer("keelan", "123", map[string]bool{"wizard":true})
+	dan, _ := db.CreatePlayer("dan", "123", nil)
 
 	outside := f.NewObject()
 	outside.Type = "room"

db.go

 	"fmt"
 	"github.com/boltdb/bolt"
 	"strconv"
+	"errors"
+	"regexp"
 )
 
 const (
 
 type DBRef int
 
-func NewDBRefFromHashRef(v string) (DBRef, error) {
+func NewDBRefFromHashRef(v string) (DBRef, bool) {
 	var destInt int
+	
+	if matched, _ := regexp.MatchString(`^\pZ*#[0-9]+\pZ*?`, v); !matched {
+		return 0, false
+	}
+
 	n, err := fmt.Sscanf(v, "#%d", &destInt)
 
 	if err != nil || n == 0 {
-		return 0, err
+		return 0, false
 	}
 
-	return DBRef(destInt), nil
+	return DBRef(destInt), true
 }
 
 func NewDBRefFromString(v string) (DBRef, error) {
 
 }
 
-
-
-
 func (s *DB) GetPlayer(name string) (PlayerMeta, bool) {
 	var player PlayerMeta
 	found := false
 	return player, found
 }
 
-func (s *DB) CreatePlayer(name string, flags map[string]string) (DBRef, error) {
+func (s *DB) DeletePlayer(name string) error {
+	return s.db.Update(func(tx *bolt.Tx) error {
+		playerBucket := tx.Bucket([]byte("player"))
+		err := playerBucket.Delete([]byte(name))
+		return err
+	})
+}
+
+func (s *DB) RenamePlayer(oldName string, newName string) error {
+	// doing it this way accomplishes the change as a single transasction
+	// and saves a bunch of marshalling and unmarshalling
+	return s.db.Update(func(tx *bolt.Tx) error {
+		playerBucket := tx.Bucket([]byte("player"))
+		buf := playerBucket.Get([]byte(oldName))
+		if buf == nil {
+			return errors.New("Can't find player")
+		}
+		err := playerBucket.Delete([]byte(oldName))
+		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
 
 		}
 		playerID = DBRef(seq)
 		s.txStoreObject(objectBucket, Object{ID: playerID, Name: name, Type: "player", Flags: flags}, playerID)
-		playerMeta := PlayerMeta{ID: playerID, Password: "password"}
+		playerMeta := PlayerMeta{ID: playerID, Password: password}
 		buf, err := json.Marshal(playerMeta)
 		if err != nil {
 			return err

object.go

 }
 
 type Object struct {
-	ID          DBRef  `json:"id"`
-	Next        DBRef  `json:"next"`
-	Type        string `json:"type"`
-	Name        string `json:"name"`
-	Description string `json:"description"`
-	Flags		map[string]string `json:"flags"`
-	Owner DBRef `json:"owner"`
+
+	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"`
+	Properties  map[string]string `json:"properties"`
+	
 	db    *DB
+	
 }
 
 type ObjectFactory struct {
 	return o.db.Link(o.ID, c.ID, c.Type)
 }
 
-func (o *Object) MatchLinkNames(matchName string, player DBRef) ObjectList {
-	if matchName == "here" {
-		return ObjectList{*o}
-	}
-	if matchName == "me" {
-		p, found := o.db.Fetch(player)
-		if !found {
-			return ObjectList{}
-		} else {
-			return ObjectList{p}
-		}
-	}
-	r := make(ObjectList, 0)
-
-	children := o.db.GetChildren(o.ID) // map[DBRef]string
-
-	for childID, _ := range children {
-		o, found := o.db.Fetch(childID)
-		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)
 
 					break // no need to look at other aliases
 				}
 			}
-
 		}
 	}
 
 }
 
 func (o *Object) DetailedName() string {
-	return fmt.Sprintf("%s (#%d)", o.Name, o.ID)
+	return fmt.Sprintf("%s <#%d>", o.Name, o.ID)
 }
 
-func (o *Object) GetLinkNames(matchType string, exclude DBRefList) []string {
+func (o *Object) GetContents(exclude DBRef) []string {
 	r := make([]string, 0)
-
-	children := o.db.GetChildren(o.ID) // map[DBRef]string
-
-childLoop:
+	children := o.db.GetChildren(o.ID)
 	for childID, linkType := range children {
-		if matchType != "*" && matchType != linkType {
-			continue
-		}
-		for _, excludeID := range exclude {
-			if excludeID == childID {
-				continue childLoop
-			}
-		}
+		if childID == exclude { continue }
+		if !(linkType == "player" || linkType == "thing") { continue }
 		o, found := o.db.Fetch(childID)
-		if found {
-			if linkType == "player" {
-				if o.GetFlag("online","false") == "true" {
-					r = append(r, o.DetailedName())
-				}
-			} else if linkType == "exit" {
-				r = append(r, o.Name)
-			} else {
-				r = append(r, o.DetailedName())
-			}
-		}
+		if !found { continue }
+		if linkType == "player" && !o.GetFlag("online") { continue }
+		r = append(r, o.DetailedName())
 	}
+	sort.Strings(r)
+	return r
+}
 
+func (o *Object) GetExits() []string {
+	r := make([]string, 0)
+	children := o.db.GetChildren(o.ID)
+	for exitID, linkType := range children {
+		if linkType != "exit" { continue }
+		exit, found := o.db.Fetch(exitID)
+		if !found { continue }
+		aliases := strings.Split(exit.Name, ";")
+		r = append(r, aliases[0])
+	}
+	
 	sort.Strings(r)
 	return r
 }
 
-func (o *Object) SetFlag(flag string, value string) {
+func (o *Object) SetFlag(flag string, value bool) {
 	if o.Flags == nil {
-		o.Flags = make(map[string]string)
+		o.Flags = make(map[string]bool)
 	}
 	o.Flags[flag]=value
 }
 
-func (o *Object) GetFlag(flag string, defaultValue string) (string) {
-	
-	if o.Flags == nil {
-		return defaultValue
-	}
+func (o *Object) GetFlag(flag string) bool {
 	
+	if o.Flags == nil { return false }
 	value, ok := o.Flags[flag]
+	if !ok { return false }
 	
-	if !ok {
-		return defaultValue
+	return value
+}
+
+func (o *Object) SetProp(key string, value string) {
+	if o.Properties == nil {
+		o.Properties = make(map[string]string)
 	}
+	o.Properties[key]=value
+}
+
+func (o *Object) GetProp(key string) string {
+	
+	if o.Properties == nil { return "" }
+	value, ok := o.Properties[key]
+	if !ok { return "" }
 	
 	return value
 }
 
 
+
+
 type ObjectList []Object
 
 func (l ObjectList) First() Object {