Gammon Forum

 1500) The chief guard   
 1501) A bend in the trail   
 1502) A distant sound   
 1503) Breaks in the trees  

 for( vnum = lrange; vnum <= trange; vnum++ )
   {
   EXIT_DATA *pexit;
   static char *dir_text[] = { "n", "e", "s", "w", "u", "d", "ne", "nw", "se", "sw", "?" };
     
      if( ( room = get_room_index( vnum ) ) == NULL )
         continue;
      pager_printf( ch, "%5d) %s Exits: ", vnum, room->name );
      
    for(pexit = room->first_exit; pexit; pexit = pexit->next )
        pager_printf( ch,
                   "%s:%-5d ",
                    dir_text[pexit->vdir],
                   pexit->to_room ? pexit->to_room->vnum : 0 );
      
    pager_printf (ch, "\r\n");
   }
   return;

 1500) The chief guard Exits: n:1576  s:1575  
 1501) A bend in the trail Exits: e:1502  nw:3588  
 1502) A distant sound Exits: n:1503  e:1520  w:1501  
 1503) Breaks in the trees Exits: n:1510  e:1506  s:1502  w:1505  

roomslist = [[
 1500) The chief guard Exits: n:1576  s:1575  
 1501) A bend in the trail Exits: e:1502  nw:3588  
 1502) A distant sound Exits: n:1503  e:1520  w:1501  
 1503) Breaks in the trees Exits: n:1510  e:1506  s:1502  w:1505  
 1504) Storage Exits: e:1505  
 
... and so on for hundreds of lines ...

24896) 223 Rasche Hall Exits: u:24899 
24897) Forrester and Cox's Room Exits: w:24898 
24898) The Third Floor Miles Hallway Exits: e:24897 s:24895 w:24899 
24899) Grant and Seguin's Room Exits: e:24898 d:24896 
 ]]

-- getlines iterator - iterates over a string and returns one item per line

function getlines (str)

  local pos = 0
  
  -- the for loop calls this for every iteration
  -- returning nil terminates the loop
  local function iterator (s)
  
    if not pos then
      return nil
    end -- end of string, exit loop
    
    local oldpos = pos + 1  -- step past previous newline
    pos = string.find (s, "\n", oldpos) -- find next newline
  
    if not pos then  -- no more newlines, return rest of string
      return string.sub (s, oldpos)
    end -- no newline
    
    return string.sub (s, oldpos, pos - 1)
    
  end -- iterator
  
  return iterator, str
end -- getlines

-- table of rooms and their exits

rooms = {}

for l in getlines (roomslist) do
  _, _, vnum, name, exits = string.find (l, "(%d+)%) (.+) Exits%: (.*)")
  if vnum then
    vnum = tonumber (vnum)
    rooms [vnum] = { name = name, exits = {} }
    string.gsub (exits, "(%a+)%:(%d+) ", 
             function (dir, where) 
                rooms [vnum].exits [dir] = tonumber (where) 
             end )
  end -- vnum found
end -- for

--------------- This part saves it all to disk ------------

f = io.output ("room_stuff.lua")

f:write ("rooms = {}\n")

for vnum, data in pairs (rooms) do
  exits = ""
  for k, v in pairs (data.exits) do
    exits = exits .. k .. "=" .. v .. ", "
  end -- for each exit  
  f:write (string.format ("rooms [%i] = { name = %q,\n   exits = {%s} }\n", vnum, data.name, exits))
end -- for loop

f:close ()

function find_paths (start, destinations)
	
	local dest_length = table.getn(destinations)
	local new_dest = {}
	for i,room in pairs(destinations) do
		new_dest[room] = true
	end
	destinations = new_dest
	
	local explored_rooms, particles = {}, {}
	
	-- this is where we collect found paths
	-- the table is keyed by destination, with paths as values
	local paths = {}
	
	-- create particle for the initial room
	table.insert (particles, make_particle (start) )
	
	while table.getn(particles) > 0 do
	
		-- create a new generation of particles
		new_generation = {}
		
		-- process each active particle
		for i,part in ipairs(particles) do
		
			-- if room doesn't exist, forget it
      		if rooms [part.current_room] then
			
				-- get a list of exits from the current room
				exits = rooms [part.current_room].exits
				
				-- create one new particle for each exit
				for dir, dest in pairs(exits) do
				
					-- if we've been in this room before, drop it
					if not explored_rooms[dest] then
						explored_rooms[dest] = true
						new_path = dup_table (part.path)
						table.insert(new_path, dir)
						
						-- if this room is in the list of destinations then save its path
						if destinations[dest] then
							paths[dest] = new_path
							dest_length = dest_length - 1
						end -- found one!
						
						-- make a new particle in the new room
	            		table.insert(new_generation, make_particle(dest, new_path))
					end
				end
			
			end
		end
		
		-- check if all destinations have been reached
		if dest_length == 0 then
			return paths
		end
			
		particles = new_generation
	end	
	return paths			
end

destinations = {}
paths = {}

-- find all paths

count = 0

print "Starting ..."
io.flush ()
t1 = os.time ()

for from_room in pairs (rooms) do
  count= count + 1
  print ("Doing room", count, "vnum", from_room)
  io.flush ()

  for to_room in pairs (rooms) do
    if from_room ~= to_room then  -- don't do to ourself
    	table.insert(destinations, to_room)
    end -- not same room
    -- if destinations table isn't empty

  end -- for each path from this room
  if table.getn(destinations) > 0 then
	paths[from_room] = find_paths(from_room, destinations)
	destinations = {} 
  end

end  -- for each room

print ("rooms = ", count)

print ("Made", particle_count, "particles to do that")

t2 = os.time ()
print ("Time taken = ", os.difftime (t2, t1), "seconds")

max_length = 0

for from_room, dests in pairs (paths) do
  for to_room, how in pairs (dests) do
    if table.getn (how) > max_length then
      max_length = table.getn (how)
      long_from = from_room
      long_to = to_room
    end -- if longer
  end -- of each to room

end -- each from room


print ("Longest path (", table.getn (paths [long_from] [long_to]), "nodes) was from", 
       long_from, "to", long_to)
print ("From ", rooms [long_from].name, "to",  rooms [long_to].name)
print ("Path = ", table.concat (paths [long_from] [long_to], ","))

if not design
  select case event
    on click
      fire_event click
    ...
  end select
else
  if event = drag then
    fire_event drag
  end if
end if