func DeleteRoom(room types.Room) {
	db.DeleteObject(room.GetId())

	// Disconnect all exits leading to this room
	loc := room.GetLocation()

	updateRoom := func(dir types.Direction) {
		next := loc.Next(dir)
		room := GetRoomByLocation(next, room.GetZoneId())

		if room != nil {
			room.SetExitEnabled(dir.Opposite(), false)
		}
	}

	updateRoom(types.DirectionNorth)
	updateRoom(types.DirectionNorthEast)
	updateRoom(types.DirectionEast)
	updateRoom(types.DirectionSouthEast)
	updateRoom(types.DirectionSouth)
	updateRoom(types.DirectionSouthWest)
	updateRoom(types.DirectionWest)
	updateRoom(types.DirectionNorthWest)
	updateRoom(types.DirectionUp)
	updateRoom(types.DirectionDown)
}

func MoveCharacterToRoom(character types.Character, newRoom types.Room) {
	oldRoomId := character.GetRoomId()
	character.SetRoomId(newRoom.GetId())

	oldRoom := GetRoom(oldRoomId)

	// Leave
	dir := DirectionBetween(oldRoom, newRoom)
	events.Broadcast(events.LeaveEvent{Character: character, RoomId: oldRoomId, Direction: dir})

	// Enter
	dir = DirectionBetween(newRoom, oldRoom)
	events.Broadcast(events.EnterEvent{Character: character, RoomId: newRoom.GetId(), Direction: dir})
}

func DirectionBetween(from, to types.Room) types.Direction {
	for _, exit := range from.GetExits() {
		nextLocation := from.NextLocation(exit)
		nextRoom := GetRoomByLocation(nextLocation, from.GetZoneId())

		if nextRoom == to {
			return exit
		}
	}

	return types.DirectionNone
}

func GetNeighbors(room types.Room) []types.Room {
	neighbors := []types.Room{}

	for _, dir := range room.GetExits() {
		coords := room.NextLocation(dir)
		neighbor := GetRoomByLocation(coords, room.GetZoneId())
		if neighbor != nil {
			neighbors = append(neighbors, neighbor)
		}
	}

	for _, id := range room.GetLinks() {
		neighbor := GetRoom(id)
		if neighbor != nil {
			neighbors = append(neighbors, neighbor)
		}
	}

	return neighbors
}

func CreatePlayerCharacter(name string, userId types.Id, startingRoom types.Room) types.PC {
	pc := db.NewPc(name, userId, startingRoom.GetId())
	events.Broadcast(events.EnterEvent{Character: pc, RoomId: startingRoom.GetId(), Direction: types.DirectionNone})
	return pc
}

func (self *Session) printRoom(room types.Room) {
	pcs := model.PlayerCharactersIn(self.pc.GetRoomId(), self.pc.GetId())
	npcs := model.NpcsIn(room.GetId())
	items := model.ItemsIn(room.GetId())
	store := model.StoreIn(room.GetId())

	var area types.Area
	if room.GetAreaId() != nil {
		area = model.GetArea(room.GetAreaId())
	}

	var str string

	areaStr := ""
	if area != nil {
		areaStr = fmt.Sprintf("%s - ", area.GetName())
	}

	str = fmt.Sprintf("\r\n %v>>> %v%s%s %v<<< %v(%v %v %v)\r\n\r\n %v%s\r\n\r\n",
		types.ColorWhite, types.ColorBlue,
		areaStr, room.GetTitle(),
		types.ColorWhite, types.ColorBlue,
		room.GetLocation().X, room.GetLocation().Y, room.GetLocation().Z,
		types.ColorWhite,
		room.GetDescription())

	if store != nil {
		str = fmt.Sprintf("%s Store: %s\r\n\r\n", str, types.Colorize(types.ColorBlue, store.GetName()))
	}

	extraNewLine := ""

	if len(pcs) > 0 {
		str = fmt.Sprintf("%s %sAlso here:", str, types.ColorBlue)

		names := make([]string, len(pcs))
		for i, char := range pcs {
			names[i] = types.Colorize(types.ColorWhite, char.GetName())
		}
		str = fmt.Sprintf("%s %s \r\n", str, strings.Join(names, types.Colorize(types.ColorBlue, ", ")))

		extraNewLine = "\r\n"
	}

	if len(npcs) > 0 {
		str = fmt.Sprintf("%s %s", str, types.Colorize(types.ColorBlue, "NPCs: "))

		names := make([]string, len(npcs))
		for i, npc := range npcs {
			names[i] = types.Colorize(types.ColorWhite, npc.GetName())
		}
		str = fmt.Sprintf("%s %s \r\n", str, strings.Join(names, types.Colorize(types.ColorBlue, ", ")))

		extraNewLine = "\r\n"
	}

	if len(items) > 0 {
		itemMap := make(map[string]int)
		var nameList []string

		for _, item := range items {
			if item == nil {
				continue
			}

			_, found := itemMap[item.GetName()]
			if !found {
				nameList = append(nameList, item.GetName())
			}
			itemMap[item.GetName()]++
		}

		sort.Strings(nameList)

		str = str + " " + types.Colorize(types.ColorBlue, "Items: ")

		var names []string
		for _, name := range nameList {
			if itemMap[name] > 1 {
				name = fmt.Sprintf("%s x%v", name, itemMap[name])
			}
			names = append(names, types.Colorize(types.ColorWhite, name))
		}
		str = str + strings.Join(names, types.Colorize(types.ColorBlue, ", ")) + "\r\n"

		extraNewLine = "\r\n"
	}

	str = str + extraNewLine + " " + types.Colorize(types.ColorBlue, "Exits: ")

	var exitList []string
	for _, direction := range room.GetExits() {
		exitList = append(exitList, utils.DirectionToExitString(direction))
	}

	if len(exitList) == 0 {
		str = str + types.Colorize(types.ColorWhite, "None")
	} else {
		str = str + strings.Join(exitList, " ")
	}
//.........这里部分代码省略.........

func (self *mapBuilder) addRoom(room types.Room, x int, y int, z int) {
	x = x * 2
	y = y * 2

	addIfExists := func(dir types.Direction, x int, y int) {
		if x < 0 || y < 0 {
			return
		}

		if room.HasExit(dir) {
			self.data[z][y][x].addExit(dir)
		}
	}

	if self.userRoom.GetId() == room.GetId() {
		self.data[z][y][x].char = '*'
		self.data[z][y][x].color = types.ColorRed
	} else {
		self.data[z][y][x].color = types.ColorMagenta
		if room.HasExit(types.DirectionUp) && room.HasExit(types.DirectionDown) {
			self.data[z][y][x].char = '+'
		} else if room.HasExit(types.DirectionUp) {
			self.data[z][y][x].char = '^'
		} else if room.HasExit(types.DirectionDown) {
			self.data[z][y][x].char = 'v'
		} else {
			char := '#'

			/*
				count := len(model.CharactersIn(room.GetId()))
				if count < 10 {
					char = rune(strconv.Itoa(count)[0])
				}
			*/

			self.data[z][y][x].char = char
			self.data[z][y][x].color = types.ColorWhite
		}
	}

	addIfExists(types.DirectionNorth, x, y-1)
	addIfExists(types.DirectionNorthEast, x+1, y-1)
	addIfExists(types.DirectionEast, x+1, y)
	addIfExists(types.DirectionSouthEast, x+1, y+1)
	addIfExists(types.DirectionSouth, x, y+1)
	addIfExists(types.DirectionSouthWest, x-1, y+1)
	addIfExists(types.DirectionWest, x-1, y)
	addIfExists(types.DirectionNorthWest, x-1, y-1)
}

func costEstimate(start, goal types.Room) int {
	c1 := start.GetLocation()
	c2 := goal.GetLocation()

	return utils.Abs(c1.X-c2.X) + utils.Abs(c1.Y-c2.Y) + utils.Abs(c1.Z-c2.Z)
}