ifmapper 0.7 → 0.8

data/lib/IFMapper/TranscriptReader.rb

@@ -0,0 +1,748 @@
+
+
+#
+# Class used to parse an Infocom-style transcript and automatically
+# generate a map.  This can be used to automatically map a game as 
+# you play it.
+#
+# This code is based on Perl code by Dave Chapeskie, used in IFM,
+# albeit it has been enhanced to handle multi-line commands, room stub
+# exits, objects parsing and the ability to parse transcripts as
+# they are being spit out.
+#
+class TranscriptReader
+
+  PROMPT   = /^>\s*/
+  LOOK     = /^l(ook)?/i
+  UNDO     = /^undo$/i
+  TELEPORT = /^(restart|restore)$/i
+  IGNORE   = /transcript/i
+  OTHERS   = /^(read|inventory$|i$)/i
+  UNSCRIPT = /^unscript$/i
+  BLANK    = /^\s*$/
+  MOVE     = /^(walk|run|go)\s+/i
+  TAKE     = /^(take|get)\s+(a\s+|the\s+)?(.*)/i
+  DROP     = /^(drop|leave)\s+()/i
+  STARTUP  = /(^[A-Z]+$|Copyright|\([cC]\)\s*\d|Trademark|Release|Version|[Ss]erial [Nn]umber|Written by)/
+  DARKNESS = /dark/i
+  DEAD     = /(You die|You have died|You are dead)/i
+
+  # Compass direction command -> direction mapping.
+  DIRMAP = {
+    "n" => 0, "north" => 0, "ne" => 1, "northeast" => 1,
+    "e" => 2, "east" => 2, "southeast" => 3, "se" => 3,
+    "south" => 4, "s" => 4, "southwest" => 5, "sw" => 5,
+    "west" => 6, "w" => 6, "northwest" => 7, "nw" => 7
+  }
+
+  ODIRMAP = {"up" => 1, "u" => 1, "down" => 2, "d" => 2,
+    "in" => 3, "out" => 4, 'enter' => 3, 'exit' => 4 }
+
+  # Direction list in order of positioning preference.
+  DIRLIST = [ 0, 4, 2, 6, 1, 3, 5, 7 ]
+
+  NAME_REMOVE   = /(\s+\(.+\)|,\s+[io]n\s+.+)/ # remove things like (on the bed)
+  NAME_INVALID  = /[\[\]\.!\?]/
+  NAME_MAXWORDS = 20
+  NAME_MAXUNCAP = 4  # so that lowercase room/end will be accepted
+
+  # Default room description recognition parameters.
+  DESC_MINWORDS = 10
+
+
+  ## Change this to non-dil to print out debugging info
+  @@debug = nil
+
+
+  def debug(*msg)
+    if @@debug
+      $stdout.puts msg
+    end
+  end
+
+  ## Possible nessages indicating get/take succeeded
+  TAKE_OK = [ 
+    /taken/i,
+    /you\s+now\s+have\s+(got\s+)?the/i,
+  ]
+
+  IT = /^(it|them)$/
+
+  #
+  # Handle a take action
+  #
+  def take(move, objs)
+    return unless @here
+    objs.each { |cmd, dummy, obj|
+      next if not obj
+
+      objlist = obj.split(',')
+      o = objlist[0]
+      if objlist.size == 1 and o != 'all'
+	# ignore 'get up'
+	next if cmd == 'get' and o == 'up'
+	o = @last_obj if o =~ IT
+	next if not o
+	status = move[:reply].to_s
+	TAKE_OK.each { |re|
+	  if status =~ re and not @objects.has_key?(o)
+	    @here.objects << o << "\n"
+	    @objects[o] = 1
+	    @last_obj = o
+	    break
+	  end
+	}
+      else
+	# Handle multiple objects
+	move[:reply].each { |reply|
+	  o, status = reply.split(':')
+	  next if not status
+	  o = @last_obj if o =~ IT
+	  if o and not @objects.has_key?(o)
+	    @here.objects << o << "\n"
+	    @objects[o] = 1
+	    @last_obj = o
+	  end
+	}
+      end
+    }
+  end
+
+  #
+  # Add a new room to the automapper
+  #
+  def add(room)
+    @rooms[room] = {:section => @map.section, :desc => nil }
+  end
+
+  #
+  # Remove some rooms from the automap knowledge (user removed these manually)
+  #
+  def remove(rooms)
+    rooms.each { |r| @rooms.delete(r) }
+  end
+
+
+  def parse
+    # Find first command prompt
+    while line = @f.gets
+      break if PROMPT =~ line
+    end
+    parse_line(line)
+  end
+
+  #
+  # Given a room description, parse it to try to find out all exits 
+  # from room.
+  #
+
+  DIRS  = {
+    'north' => 0, 'northeast' => 1, 'east' => 2, 'southeast' => 3, 'south' => 4,
+    'southwest' => 5, 'west' => 6, 'northwest' => 7
+  }
+
+  DIR = '(' + DIRS.keys.join('|') + ')'
+  OR = '(and|or)'
+
+  EXITS_REGEX = 
+    [
+    # You can go south or east
+    /you\s+can\s+go\s+#{DIR}\s+#{OR}\s+#{DIR}[,\.\s+]/i,
+    # You can go south
+    /you\s+can\s+go\s+#{DIR}[,\.\s+]/i,
+    # to the east or west
+    /to\s+the\s+#{DIR}\s+#{OR}\s+#{DIR}[,\.\s+]/i,
+    # to the east
+    /to\s+the\s+#{DIR}[,\.\s+]/i,
+    # paths lead west and north
+    /(run|lead|wander|winds)\s+#{DIR}\s+#{OR}\s+#{DIR}[,\.\s+]/i, 
+    # east-west corridor
+    /[\.\s+]#{DIR}[\/-]#{DIR}[,\.\s+]/i, 
+    # East is the postoffice
+    /[,\.\s+]#{DIR}\s+is/i,
+    # continues|lies|etc... east
+    /(runs|leads|heads|opens|winds|continues|branches|lies|wanders|bends|curves)\s+#{DIR}[,\.\s+]/i,
+    /(running|leading|heading|opening|branching|lying|wandering|looking|bending)\s+#{DIR}[,\.\s+]/i,
+  ]
+
+  EXITS_SPECIAL = { 
+    /four\s+directions/i => [0, 2, 4, 6],
+    /four\s+compass\s+points/i => [0, 2, 4, 6],
+    /all\s+directions/i  => [0, 1, 2, 3, 4, 5, 6, 7],
+  }
+
+  def parse_exits(r, desc)
+    return if not desc
+    exits = []
+
+    # Remove \n from descriptions
+    desc.gsub(/\n/, ' ')
+
+    # Now, start searching for stuff
+
+    # First try the special directions...
+    EXITS_SPECIAL.each { |re, dirs|
+      if desc =~ re
+	exits += dirs
+	break
+      end
+    }
+
+    # If that failed, start searching for exits
+    if exits.empty?
+      EXITS_REGEX.each { |re|
+	matches = desc.scan(re)
+	next if matches.empty?
+	matches.each { |arr|
+	  arr.each { |m|
+	    next unless DIRS[m]
+	    exits << DIRS[m]
+	  }
+	}
+      }
+    end
+
+    exits.uniq!
+
+    # Add a 'stub' for the new connection
+    exits.each { |exit|
+      next if r[exit]
+      c = @map.new_connection( r, exit, nil )
+      c.dir = Connection::AtoB
+      debug "\tADDED STUB #{c}"
+    }
+  end
+
+  def parse_line(line)
+    return unless line
+
+    @moves.clear
+
+    #
+    # Read all commands
+    #
+    loop do
+      line.sub!(PROMPT, '')
+      line.chop!
+      line.sub!(/\s+$/, '')
+      cmd = line
+
+      # Read reply
+      reply = []
+      while line = @f.gets
+	break if line =~ PROMPT
+	line.chop!
+	line.sub!(/\s+$/,'')
+	reply << line
+      end
+
+      break if not line
+
+      if cmd =~ UNDO
+	@moves.pop
+      else
+	move = { }
+	move[:cmd]   = cmd
+	move[:reply] = reply
+	@moves << move
+      end
+
+    end
+
+
+    # Step 2
+    tele = nil
+    @moves.each { |move|
+      cmd = move[:cmd]
+      next if cmd =~ IGNORE or cmd =~ OTHERS
+      if cmd =~ UNSCRIPT
+	tele = 1
+	next
+      end
+
+      tele = 1 if cmd =~ TELEPORT
+
+      name = nil
+      desc = ''
+      roomflag = false
+      desc_gap = false
+      startup = false
+      rooms = []
+      move[:reply].each { |r|
+	tele = 1 if r =~ DEAD
+
+	if r =~ STARTUP
+	  # Dealing with a startup message, such as:
+	  # MY GAME
+	  # Copyright (C) 1984 ComputerQuest
+	  # We skip the whole thing until the next blank line
+	  debug "#{r} skipped due to startup"
+	  startup = true
+	  desc = ''
+	  name = nil
+	  roomflag = false
+	  desc_gap = false
+	  next
+	end
+	next if startup and r !~ BLANK
+	startup = false
+
+	if not roomflag and r !~ BLANK and roomname(r)
+	  debug "set roomflag with #{r}"
+	  roomflag = true
+	  name = r
+	  next
+	end
+
+	break if roomflag and desc_gap and r =~ BLANK
+
+	desc_gap = true if roomflag and r =~ BLANK
+
+
+	if roomflag and r !~ BLANK
+	  desc << r << "\n"
+	end
+
+	if r =~ BLANK and roomflag # and desc != ''
+
+	  if desc.count("\n") == 1 and desc =~ /\?$/
+	    # A "What next?" type of prompt, not a room description
+	    desc = ''
+	  end
+	  desc = nil if desc == ''
+
+	  rooms << {
+	    :name => name,
+	    :desc => desc,
+	    :tele => tele
+	  }
+	  roomflag = false
+	  desc_gap = false
+	  name = nil
+	  desc = ''
+	  tele = nil
+	end
+      }
+
+      if not rooms.empty?
+	move[:rooms] = rooms
+	move[:look]  = true if cmd =~ LOOK
+	move[:reply] = nil
+      end
+    }
+
+
+    @moves.each { |move|
+      cmd  = move[:cmd]
+      if objs = cmd.scan(TAKE)
+	take(move, objs)
+      end
+	
+      next unless move[:rooms]
+      move[:rooms].each { |room|
+	name = room[:name]
+	debug "SECTION: #{@map.section}"
+	debug "HERE IS: #{@here}"
+	debug "CMD:     #{cmd}"
+	debug "ENDS AT: #{name}"
+
+	desc = room[:desc]
+	line = move[:line]
+	cmd  = move[:cmd]
+	
+	# If we teleported, try to find room 
+	if room[:tele]
+	  debug "\t ****TELEPORT TO #{name}****"
+	  @here = find_room(name, desc)
+	  debug "\t TO: #{@here}"
+	end
+
+	# If it is a look command or we don't know where we are yet,
+	# set current room.
+	if move[:look] or not @here
+	  @here = new_room(move, name, desc) unless @here
+	  @here.selected = true
+	  next
+	end
+
+	# Otherwise, assume we moved in some way.  Try to find the new room.
+	there = find_room(name, desc)
+	next if there == @here
+
+	cmd.sub!(MOVE, '')
+	if DIRMAP[cmd]
+	  dir = DIRMAP[cmd]
+	  go  = nil
+	  cmd = nil
+	elsif ODIRMAP[cmd]
+	  go  = ODIRMAP[cmd]
+	  dir = choose_dir(@here, there, go)
+	  cmd = nil
+	else
+	  # special move ---
+	  dir = choose_dir(@here, there)
+	  go  = nil
+	end
+
+	@here.selected = false
+	if not there
+	  # Unvisited -- new room
+	  @here = new_room(move, name, desc, dir, @here, go, cmd)
+	else
+	  # Visited before -- new link
+	  new_link(move, @here, there, dir, go, cmd)
+	  @here = there
+	end
+      }
+    }
+
+    @moves.clear
+    @map.fit
+    if @map.kind_of?(FXMap)
+      @here.selected = true if @here
+      @map.zoom = @map.zoom
+      @map.center_view_on_room(@here) if @here
+      @map.verify_integrity
+      @map.draw
+    end
+  end
+
+  def find_room(name, desc)
+    bestscore = 0
+    best = nil
+    @rooms.each { |r, room|
+      score = 0
+
+
+      if desc and room[:desc]
+	# We have a description...
+	# Try exact description match first
+	score += 10 if room[:desc] == desc
+
+	# Try substring match
+	score += 5 if room[:desc].index(desc)
+
+	# If still no luck, try first N words
+	if score == 0
+	  dwords = room[:desc].split(' ')
+	  words  = desc.split(' ')
+	  match  = true
+	  0.upto(DESC_MINWORDS) { |i|
+	    if words[i] != dwords[i]
+	      match = false
+	      break
+	    end
+	  }
+
+	  score += 2 if match
+	end
+      else
+	# Just the name, not so good
+	score += 1 if r.name == name
+      end
+      next if score <= bestscore
+      bestscore = score
+      best = [r, room[:section]]
+    }
+    return nil if not best
+    
+    if best[1] != @map.section
+      debug "\t ------> #{best[0]} in section #{best[1]}"
+      @map.section = best[1]
+    end
+    return best[0]
+  end
+
+  #
+  # Determine if line corresponds to a room name
+  #
+  def roomname(line)
+    # Remove unwanted stuff
+    line.sub!(NAME_REMOVE, '')
+
+    # quick check for invalid format
+    return false if line =~ NAME_INVALID
+    return false unless line =~ /\w/
+
+    # Check word count
+    words = line.split(' ')
+    return false if words.size > NAME_MAXWORDS
+
+    # Check uncapitalized words
+    return false if line =~ /^[ a-z\/\\\-\(\)]/
+
+    words.each { |w|
+      return false if w =~ /^[a-z]/ and w.size > NAME_MAXUNCAP 
+    }
+    return true
+  end
+
+  #
+  # Create a new room
+  #
+  def new_room( move, name, desc, dir = nil, from = nil, go = nil, cmd = nil )
+    if not from
+      debug "FROM undefined.  Increase section #{name}"
+      @section += 1
+      @map.new_section if @section >= @map.sections.size
+      r = @map.new_room(0, 0)
+      r.name = name
+    else
+      x = from.x
+      y = from.y
+      dx, dy = Room::DIR_TO_VECTOR[dir]
+      x += dx
+      y += dy
+      @map.shift(x, y, dx, dy) if not @map.free?(x, y) 
+
+      if not @map.free?(x, y)
+	raise "Error when shifting rooms"
+      end
+
+      debug "+++ New Room #{name} from #{from}"
+      r = @map.new_room(x, y)
+      r.name = name
+      c = nil
+      if from[dir]
+	# oops, we had a connection there. 
+	c = from[dir]
+	b = c.roomB
+	if not b
+	  # Stub connection.  Update it.
+	  debug "\tUPDATE #{c}"
+	  odir = (dir + 4) % 8
+	  c.roomB = r
+	  r[odir] = c
+	  debug "\tNOW IT IS #{c}"
+	elsif b.name =~ DARKNESS
+	  # Was it a dark room that is now lit?
+	  @map.delete_connection(c)
+	  @map.delete_room(b)
+	  r.darkness = true
+	  c = nil
+	else
+	  # Probably a link that is complex
+	  # or oneway.  Shift it to some other location
+	  exitB = b.exits.rindex(c)
+	  shift_link(from, dir)
+	  c = nil
+	end
+      end
+      if c == nil
+	c = @map.new_connection( from, dir, r )
+	c.exitAtext = go if go
+	c.dir = Connection::AtoB
+      end
+    end
+
+    parse_exits(r, desc)
+
+    # Update room description
+    @rooms[r][:desc] = desc
+    return r
+  end
+
+  def shift_link(room, dir)
+    idx = dir + 1
+    idx = 0 if idx > 7
+    while idx != dir
+      break if not room[idx]
+      idx += 1
+      idx = 0 if idx > 7
+    end
+    if idx != dir
+      room[idx] = room[dir]
+      room[dir] = nil
+      # get position of other room
+      ox, oy = Room::DIR_TO_VECTOR[dir]
+      c = room[idx]
+      if c.roomA == room
+	b = c.roomB
+      else
+	b = c.roomA
+      end
+      x, y = [b.x, b.y]
+      x -= ox
+      y -= oy
+      dx, dy = Room::DIR_TO_VECTOR[idx]
+      @map.shift(x, y, -dx, -dy)
+    else
+      raise "Warning.  Cannot shift connection."
+    end
+  end
+
+  def new_link(move, from, to, dir, go, cmd)
+    odir = (dir + 4) % 8
+    c = nil
+    if from[dir]
+      c = from[dir]
+      debug "\tMOVE #{c} DIR: #{dir}"
+      if not c.roomB
+	# Stub connection, fill it
+	c.roomB  = to
+	debug "\tREMOVE #{to[odir]}"
+	@map.delete_connection(to[odir]) if to[odir] and to[odir].stub?
+	to[odir] = c
+	debug "\tREPLACED WITH #{c}"
+      elsif c.roomB == to
+	# We already went this way.  Nothing to do.
+	debug "\tWE ALREADY PASSED THRU HERE"
+      elsif c.roomA == to
+	# We verified we can travel thru this connection in both
+	# directions.  Change its status to both.
+	c.dir = Connection::BOTH
+	debug "\tSECTION: #{@map.section}"
+	debug "\tVERIFIED EXIT BOTH WAYS"
+      else
+	if c.roomA == from
+	  b = c.roomB
+	  if b.name =~ DARKNESS
+	    @map.delete_connection(c)
+	    @map.delete_room(b)
+	    to.darkness = true
+	    c = nil
+	  else
+	    dir = Room::DIRECTIONS[dir]
+	    @map.cannot_automap "Maze detected.\n'#{from}' #{dir} leads to '#{c.roomB}',\nnot to this '#{to}'."
+	    return nil
+	  end
+	else
+	  # We have a connection that turns.  Move the link around
+	  shift_link(from, dir)
+	  c = nil
+	end
+      end
+    elsif to[odir]
+      c = to[odir]
+      if not c.roomB
+	debug "\tREMOVE #{to[odir]} and REPLACE with #{c}"
+	# Stub connection, fill it
+	c.roomB   = from
+	# @map.delete_connection(from[dir]) if from[dir].stub?
+	from[dir] = c
+	c.dir = Connection::BtoA
+	c.exitBtext = go if go
+      elsif c.roomB == from
+	c.exitBtext = go if go
+      else
+	# We need to change odir to something else
+	# shift_link(to, odir)
+	odir = choose_dir(to, from, go)
+	c = nil
+      end
+    end
+
+    if not c
+      # First, check all from exits that are AtoB to see if we have one
+      # that goes to the room we want.
+      from.exits.each_with_index { |e, idx|
+	next unless e
+	if e.roomA == to and e.dir == Connection::AtoB
+	  c = e
+	  from[idx] = nil
+	end
+      }
+      if c
+	# If so, make that connection go both ways and attach it to
+	# current direction.
+	from[dir] = c
+	c.dir = Connection::BOTH
+      end
+    end
+
+    if not c
+      # No link exists -- create new one
+      begin
+	c = @map.new_connection( from, dir, to, odir )
+	c.exitAtext = go if go
+	c.dir = Connection::AtoB
+      rescue
+      end
+    end
+
+    return c
+  end
+
+
+  # Choose a direction to represent up/down/in/out.
+  def choose_dir(a, b, go = nil)
+    best = nil
+    bestscore = 0
+    if go
+      rgo = go % 2 == 0? go - 1 : go + 1
+      debug "#{Connection::EXIT_TEXT[go]} <=> #{Connection::EXIT_TEXT[rgo]}"
+      # First, check if room already has exit moving towards other room
+      a.exits.each_with_index { |e, idx|
+	next if not e
+	roomA = e.roomA
+	roomB = e.roomB
+	if roomA == a and roomB == b and e.exitBtext == rgo
+	  e.exitAtext = go
+	  return idx
+	elsif roomB == a and roomA == b and e.exitAtext == rgo
+	  e.exitBtext = go
+	  return idx
+	end
+      }
+    end
+
+    # No such luck... Pick a direction.
+    DIRLIST.each { |dir|
+      # We prefer straight directions to diagonal ones
+      inc   = dir % 2 == 1 ? 1 : 3
+      rdir  = (dir + 4) % 8
+      score = 0
+      # We prefer directions where both that dir and the opposite side
+      # are empty.
+      score += inc unless a[dir]
+      score += 1   unless a[rdir]
+      next if score <= bestscore
+      bestscore = score
+      best = dir
+    }
+
+    if bestscore == 0
+      $stderr.puts "No free exit for up/down"
+    end
+
+    return best
+  end
+
+  def stop
+    @t.stop
+  end
+
+  def destroy
+    @t.kill
+    @f.close
+    GC.start
+  end
+
+  def initialize(map, file)
+    @file     = file
+    @map      = map
+    @objects  = {}
+    @moves    = []
+    @rooms    = {}
+    @here     = nil
+    @section  = -1
+    @last_obj = nil
+  end
+
+  def start
+    @f = File.open(@file, 'r')
+    parse
+    @t = Thread.new { 
+      loop do
+	begin
+	  parse_line(@f.gets)
+	rescue => e
+	  puts e
+	  puts e.backtrace
+	end
+	Thread.pass
+      end
+    }
+    @t.run
+  end
+end