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, " ")
}
if len(room.GetLinks()) > 0 {
str = fmt.Sprintf("%s\r\n\r\n %s %s",
str,
types.Colorize(types.ColorBlue, "Other exits:"),
types.Colorize(types.ColorWhite, strings.Join(room.LinkNames(), ", ")),
)
}
str = str + "\r\n"
self.WriteLine(str)
}
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)
}
