Gammon Forum

---> Winding Passage ---> Winding Passage --|
                              |             |
                              ^             v
                              |             |
                              ----<----------

dofile "room_stuff.lua"  -- room definitions

function sortExitsTable(exit_tab)
  local labels = {}
  for label,_ in pairs(exit_tab) do
    table.insert(labels, label)
  end
  
  table.sort(labels)
  return labels

end

function sortExitsList(exit_list)
  local exit_list = exit_list
  table.sort(exit_list)
  return exit_list
end



-- a map object that implements all methods for
-- getting rooms, etc.
map = {}

map.rooms = rooms

map.getRoomSignature = function (vnum)
  local room = map.rooms[vnum]
  if not room then
    return nil
  end
  
  local sig = room.name
  sig = sig .. " Exits: " .. table.concat(sortExitsTable(room.exits), ",")
  return sig
end


map.makeRoomSignature = function(room_name, room_exits)
  local sig = room_name
  sig = sig .. " Exits: " .. table.concat(sortExitsList(room_exits), ",")
  return sig
end

map.getRooms = function(room_name, room_exits)
  local sig = map.makeRoomSignature(room_name, room_exits)
  local rooms = {}
  for vnum,room in pairs(map.rooms) do
    if map.getRoomSignature(vnum) == sig then
      table.insert(rooms, vnum)
    end
  end
  
  return rooms
end

map.getRoom = function(vnum)
  return map.rooms[vnum]
end

-- An object implementing all movement-related methods
function Tracker(init_room_id)
  local t = {}

  -- An attribute holding the current room's presumed ID
  t.current_room = init_room_id

 
  -- Holds a history of moves
  t.moves = {}
  
  -- This is called on each move
  t.move = function(dir)

    local room = map.getRoom(t.current_room)
    -- add target room and move to history
    table.insert(t.moves, dir)
      
  end
  
  -- This is called when doing a LOOK command, or any other command
  -- that results in a room display without actual movement
  t.look = function()
    table.insert(t.moves, "look")
  end
  
  t.room_display = function(room_name, room_exits)
    local exit_taken = table.remove(t.moves, 1)
    
    local room = map.getRoom(t.current_room)
    local targ_rsig = map.getRoomSignature(room.exits[exit_taken])
    local this_rsig = map.makeRoomSignature(room_name, room_exits)
    
    if not room.exits[exit_taken] then
      return true
    elseif exit_taken == "look" then
      return true
    elseif targ_rsig == this_rsig then
      t.current_room = room.exits[exit_taken]
      return true
    else
      return nil
    end
  end
  
  -- Call this when a failed move is encountered
  t.undo_move = function()
    table.remove(t.moves,1)
  end
  
  
  return t
end 


-- Call to start searching for the current location when lost
function findCurrentLocation(room_name, room_exits)
  
  -- search the map for any rooms with the given signature
  local rooms = map.getRooms(room_name, room_exits)
  
  -- create a separate Walker for each room returned by the map
  local trackers = {}
  for _, vnum in ipairs(rooms) do
  	table.insert(trackers, Tracker(vnum))
  end
  
  -- return the list of generated Walker objects
  return trackers

end



function Locator()
  local t = {}
  
  t.trackers = {}
  
  
  t.init = function(room_name, room_exits)
    t.trackers = findCurrentLocation(room_name, room_exits)
  end

  t.move = function(dir)
    if table.getn(t.trackers) == 0 then
      return nil
    end
    
    for _, tracker in ipairs(t.trackers) do
      tracker.move(dir)
    end
    return true
  end


  t.room_display = function(room_name, room_exits)
    if table.getn(t.trackers) == 0 then
      t.init(room_name, room_exits)
    end

    local new_trackers = {}
    for _, tracker in ipairs(t.trackers) do
      if tracker.room_display(room_name, room_exits) then
        table.insert(new_trackers, tracker)
      end      
    end
    
    t.trackers = new_trackers
    
    
    if table.getn(t.trackers) == 0 then
      t.init(room_name, room_exits)
    end
  
  end
        
  
  t.undo_move = function()
    for _,tracker in ipairs(t.trackers) do
      tracker.undo_move()
    end
  end
  
  t.look = function()
    for _, tracker in ipairs(t.trackers) do
      tracker.look()
    end
  end
  
  
  t.getCurrentRoom = function()
    
    if table.getn(t.trackers) == 1 then
      return t.trackers[1].current_room
    else
      return nil
    end
  
  end
  
  
  return t

end


loc = Locator()

function checkPosition(pos)
  if loc.getCurrentRoom() == pos then
    print ("Position correct: " .. tostring(pos))
  else
    print ("Test was failed! Position: " .. tostring(loc.getCurrentRoom()) )
  end
end


-- Do a short walk to ensure that it works at all
--
-- start at 21013
loc.init("Hawk Street", {"s", "n"})

-- move 'n' to 21012
loc.move('n')
loc.room_display("Intersection of Horizon Road and Hawk Street", {'s','e','w','n'})

-- move 's' back to 21013
loc.move('s')
loc.room_display("Hawk Street", {"s", "n"})

checkPosition(21013)


-- Simulate three moves in correct directions with one failure
--
-- start at 21013
loc.init("Hawk Street", {"s", "n"})

-- move 'n' to 21012
loc.move('n')

-- move 'n' to 21011
loc.move('n')

-- move 'n', presumably to 21010
loc.move('n')

-- arrive message received for 21012
loc.room_display("Intersection of Horizon Road and Hawk Street", {'s','e','w','n'})

-- a move failed, so one room display is missing
loc.undo_move()

-- arrive message received for 21011
loc.room_display("Hawk Street", {'s','n'} )

-- current position should be 21011
checkPosition(21011)


-- Three moves, one in a non-existant direction
--
-- start at 21013
loc.init("Hawk Street", {"s", "n"})

-- move 'n' to 21012
loc.move('n')

-- move 'ne' - direction doesn't exist
loc.move('ne')

-- move 'n' to 21011
loc.move('n')

-- arrive message received for 21012
loc.room_display("Intersection of Horizon Road and Hawk Street", {'s','e','w','n'})

-- move failed
loc.undo_move()

-- arrive message for 21011
loc.room_display("Hawk Street", {'s','n'} )

-- current position should be 21011
checkPosition(21011)