Bit of flags, some permissions, passwords.

client.go

 		fallthrough
 	case "connect":
 		if len(fields) == 3 {
-			playerID, err := c.db.GetPlayerID(fields[1])
-			if err != nil {
+			player, found := c.db.GetPlayer(fields[1])
+			if !found || (found && player.Password != fields[2]) {
 				c.write("Bad username or password.\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),
+			}
 
-			c.playerID = playerID
+			c.outbound = c.eventDistributor.Subscribe(subReq)
+			c.sendCommand("look")
+		} else {
+			c.write("What?\n")
+		}
+	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")
+				break
+			}
+			
+			c.playerID = player.ID
 			c.authenticated = true
 
 			// when a player authenticates, the ipc channels get turned on

cmd/funmow/main.go

 
 	f := funmow.NewObjectFactory(db)
 
-	keelan, _ := db.CreatePlayer("keelan")
-	dan, _ := db.CreatePlayer("dan")
+	keelan, _ := db.CreatePlayer("keelan", map[string]string{"wizard":"true"})
+	dan, _ := db.CreatePlayer("dan", nil)
 
 	outside := f.NewObject()
 	outside.Type = "room"

db.go

 	"bytes"
 	"encoding/binary"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"github.com/boltdb/bolt"
 	"strconv"
 	})
 }
 
-func (s *DB) SetPlayerID(name string, id DBRef) error {
+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 }
+	
 		b := tx.Bucket([]byte("player"))
-		if b == nil {
-			return errors.New("Player bucket not found")
-		}
-		return b.Put([]byte(name), id.Key())
+		
+		return b.Put([]byte(name), buf)
 	})
 
-	if DEBUG {
-		fmt.Printf("SetPlayerID name: %s id: %d\n", name, id)
-	}
-
 	return err
 
 }
 
-func (s *DB) GetPlayerID(name string) (DBRef, error) {
-	var id DBRef
-	err := s.db.View(func(tx *bolt.Tx) error {
+
+
+
+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"))
-		if b == nil {
-			return errors.New("Player bucket not found")
-		}
 		v := b.Get([]byte(name))
-		if v == nil {
-			return errors.New("Player not found")
+		if v == nil { return nil }
+		err := json.Unmarshal(v, &player)
+		if err == nil {
+			found = true
 		}
-		id = NewDBRefFromKey(v)
 		return nil
 	})
 
-	if DEBUG {
-		fmt.Printf("GetPlayerID name: %s id: %d\n", name, id)
-	}
-
-	return id, err
+	return player, found
 }
 
-func (s *DB) CreatePlayer(name string) (DBRef, error) {
+func (s *DB) CreatePlayer(name string, flags map[string]string) (DBRef, error) {
 
 	var playerID DBRef
 
 			return err
 		}
 		playerID = DBRef(seq)
-		s.txStoreObject(objectBucket, Object{ID: playerID, Name: name, Type: "player"}, playerID)
-		err = playerBucket.Put([]byte(name), playerID.Key())
+		s.txStoreObject(objectBucket, Object{ID: playerID, Name: name, Type: "player", Flags: flags}, playerID)
+		playerMeta := PlayerMeta{ID: playerID, Password: "password"}
+		buf, err := json.Marshal(playerMeta)
+		if err != nil {
+			return err
+		}
+		err = playerBucket.Put([]byte(name), buf)
 		return err
 	})
 

event_distributor.go

 	EventTypeTeardown
 	EventTypeTeardownComplete
 	EventTypeForce
+	EventTypeLogin
+	EventTypeSystem
 )
 
 type PlayerEvent struct {
 					execContext: c,
 					connInbound: make(map[int]chan PlayerEvent),
 				}
+				// mark player as online, and tell everyone!
+				e.players[sub.playerID].execInbound <- PlayerEvent{messageType: EventTypeLogin}
 			}
 			reg := e.players[sub.playerID]
 			reg.connInbound[sub.connectionID] = sub.inbound
 				e.broadcastEvent(event, false)
 			case EventTypeWall:
 				e.broadcastEvent(event, false)
+			case EventTypeSystem:
+				e.broadcastEvent(event, false)
 			}
 		}
 	}

execution_context.go

 	if !found {
 		return nil
 	}
+	
+	
 
 	c.actor = actor
 	c.outbound = outbound
 			}
 			c.HandleEvent(event)
 		}
+		// mark player as offline
+		if c.actor.Type == "player" {
+			c.actor.SetFlag("online", "false")
+			c.actor.Commit()
+		}
 		// and finally we tell the event distributor to delete us.
 		c.outbound <- PlayerEvent{src: c.actor.ID, dst: c.actor.ID, messageType: EventTypeTeardownComplete}
 	}()
 func (c *ExecutionContext) HandleEvent(m PlayerEvent) {
 	inside, _ := c.db.GetParent(c.actor.ID)
 	switch m.messageType {
+	case EventTypeLogin:
+		if c.actor.Type == "player" {
+			c.actor.SetFlag("online", "true")
+			c.actor.Commit()
+			inside, _ := c.db.GetParent(c.actor.ID)
+			c.system("Yay! %s has connected! Oh boy!", c.actor.Name)
+			c.oemit(inside, "You hear a rustling as %s awakens from a slumber.", c.actor.Name)
+		}
 	case EventTypeEmit:
 		fallthrough
 	case EventTypeOEmit:
 		if !found {
 			break
 		}
-		c.output("In the distance, you hear %s bellow out \"%s\"", speaker.Name, m.message)
+		c.output("In the distance, you hear %s bellow out: \"%s\"", speaker.Name, m.message)
+	case EventTypeSystem:
+		c.output(m.message)
 	case EventTypePage:
 		speaker, found := c.db.Fetch(m.src)
 		if !found {
 		c.destroyCmd(strings.TrimPrefix(message, "@destroy "))
 	case strings.HasPrefix(message, "@force "):
 		c.forceCmd(message)
+	case strings.HasPrefix(message, "@wizard "):
+		c.playerFlagCmd(message, "wizard")
+		
 	default:
 		if !c.goCmd(message) {
 			c.output("What?\n")
 	}
 
 	objectID, err := NewDBRefFromHashRef(objectName)
-	wizard := false
+	wizard := c.actor.GetFlag("wizard","false") == "true"
 	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 {
+		if object.Type != "thing" && object.Type != "player" {
 			c.output("Some things just can't be forced.")
+			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}
+
 	} 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 {
+			if object.Type != "thing" && object.Type != "player" {
 				c.output("Some things just can't be forced.")
+				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}
 		case MatchNone:
 			c.output("I don't see that here.")
 		case MatchMany:
 			c.output("You can't pick yourself up.")
 			return
 		}
+		if object.Type == "room" {
+			c.output("You can't carry a whole room, silly!")
+			return
+		}
 		err := c.actor.Contains(&object)
 		if err != nil {
 			return
 
 	switch matchType {
 	case MatchOne:
+		if object.Type == "player" {
+			c.output("Maybe you should seek consent prior to entering another player.")
+			return
+		}
+		if object.Type == "exit" {
+			c.output("This s not how exits are meant to be used.")
+			return
+		}
 		if object.ID == c.actor.ID {
 			c.output("Entering yourself would be a bad idea.")
 			return
 		candidate.Name = name
 		candidate.Commit()
 		c.output("Name set.")
-		//c.actor.Refresh()
 	case MatchNone:
 		c.output("I don't see that here.")
 	case MatchMany:
 
 }
 
+
+
+func (c *ExecutionContext) playerFlagCmd(input string, flag string) {
+	r, _ := regexp.Compile(`^@`+flag+`\pZ+([^=]*[^=\pZ]{1})\pZ*=\pZ*(.*)\pZ*$`)
+	params := r.FindStringSubmatch(input)
+	if params == nil {
+		return
+	}
+
+	playerName, value := params[1], params[2]
+
+	playerMeta,found := c.db.GetPlayer(playerName)
+	
+	
+	if found {
+	
+		player, found := c.db.Fetch(playerMeta.ID)
+
+		if !found {
+			return
+		}
+		
+		player.SetFlag(flag, value)
+		player.Commit()
+		c.output("It is so.")
+	} else {
+		c.output("I don't know who that is.")
+	}
+}
+
 func (c *ExecutionContext) descCmd(input string) {
 
 	r, _ := regexp.Compile(`^@desc\pZ+([^=]*[^=\pZ]{1})\pZ*=\pZ*(.*)\pZ*$`)
 		c.output("That doesn't exist.")
 		return
 	}
+	
+	if newRoom.Type == "exit" {
+		c.output("As fun is it sounds, you're not going to teleport into an exit.")
+		return
+	}
+	
+	if newRoom.Type == "player" {
+		c.output("Teleporting into other players is very impolite.")
+		return
+	}
+	
+	if newRoom.ID == c.actor.ID {
+		c.output("Teleporting to yourself is generally considered dangerous.")
+		return
+	}
 
 	c.output("You feel an intense wooshing sensation.")
 	err = newRoom.Contains(&c.actor)
 
 }
 
+func (c *ExecutionContext) wall(format string, a ...interface{}) {
+
+	message := fmt.Sprintf(format, a...)
+	c.outbound <- PlayerEvent{src: c.actor.ID, message: message, messageType: EventTypeWall}
+
+}
+
+func (c *ExecutionContext) system(format string, a ...interface{}) {
+
+	message := fmt.Sprintf(format, a...)
+	c.outbound <- PlayerEvent{src: c.actor.ID, message: message, messageType: EventTypeSystem}
+
+}
+
 func (c *ExecutionContext) oemit(audience DBRef, format string, a ...interface{}) {
 
 	message := fmt.Sprintf(format, a...)

object.go

 	MatchMany
 )
 
+type PlayerMeta struct {
+	ID          DBRef  `json:"id"`
+	Password    string `json:"password"`
+}
+
 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"`
+	Flags		map[string]string `json:"flags"`
 	Owner DBRef `json:"owner"`
 	db    *DB
 }
 		}
 		o, found := o.db.Fetch(childID)
 		if found {
-			if linkType == "exit" {
+			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())
 	return r
 }
 
+func (o *Object) SetFlag(flag string, value string) {
+	if o.Flags == nil {
+		o.Flags = make(map[string]string)
+	}
+	o.Flags[flag]=value
+}
+
+func (o *Object) GetFlag(flag string, defaultValue string) (string) {
+	
+	if o.Flags == nil {
+		return defaultValue
+	}
+	
+	value, ok := o.Flags[flag]
+	
+	if !ok {
+		return defaultValue
+	}
+	
+	return value
+}
+
+
 type ObjectList []Object
 
 func (l ObjectList) First() Object {