ifmapper 0.8.5 → 0.9

data/lib/IFMapper/InformReaderOld.rb

@@ -0,0 +1,778 @@
+
+require "IFMapper/Map"
+
+class FXMap; end
+
+#
+# Class that allows creating a map from an Inform source file.
+#
+class InformReader
+
+  class ParseError < StandardError; end
+  class MapError < StandardError; end
+
+  # Take a quoted Inform string and return a valid ASCII one, replacing
+  # Inform's special characters.
+  def self.inform_unquote(text)
+    return '' unless text
+    text.gsub!(/\~/, '"')
+    text.gsub!(/\^/, "\n")
+    while text =~ /(@@(\d+))/
+      text.sub!($1, $2.to_i.chr)
+    end
+    return text
+  end
+
+  # Temporary classes used to store inform room information
+  class InformObject
+    attr_reader   :name
+    attr_accessor :tag, :location, :enterable
+
+    def name=(x)
+      @name = InformReader::inform_unquote(x)
+    end
+
+    def to_s
+      "#@name tag:#@tag"
+    end
+    def initialize()
+      @location  = []
+      @enterable = []
+    end
+  end
+
+  class InformDoor
+    attr_accessor :location
+    attr_accessor :locked
+    attr_accessor :tag
+    def method_missing(*x)
+    end
+    def initialize
+      @location = []
+    end
+  end
+
+  class InformRoom
+    attr_reader   :name
+    attr_accessor :exits, :tag, :darkness
+    def to_s
+      "#@name tag:#@tag"
+    end
+    def name=(x)
+      @name = InformReader::inform_unquote(x)
+    end
+    def initialize
+      @exits    = Array.new(12, nil)
+      @darkness = true
+    end
+  end
+
+
+  DIRECTIONS = { 
+    'n_to' => 0,
+    'ne_to' => 1,
+    'e_to' => 2,
+    'se_to' => 3,
+    's_to' => 4,
+    'sw_to' => 5,
+    'w_to' => 6,
+    'nw_to' => 7,
+    'u_to' => 8,
+    'd_to' => 9,
+    'in_to' => 10,
+    'out_to' => 11
+  }
+
+  FUNCTION = /^\[ (\w+);/
+
+  GO_OBJ = /\b(#{DIRECTIONS.keys.join('|').gsub(/_to/, '_obj')})\s*:/i
+
+
+  # Direction list in order of positioning preference.
+  DIRLIST = [ 0, 4, 2, 6, 1, 3, 5, 7 ]
+
+  NAME      = /(?:^|\s+)p?name\s+/i
+  DIR_TO    = /(?:^|\s+)(#{DIRECTIONS.keys.join('|')})\s+/i
+
+  DIR       = /(?:^|\s+)(#{DIRECTIONS.keys.join('|')})\s+(\w+)/i
+  ENTER_DIR = /(?:^|\s+)(#{DIRECTIONS.keys.join('|')})\s+\[;\s*<<\s*Enter\s+(\w+)\s*>>/i
+
+  attr_reader :map
+
+  @@debug = 1
+  def debug(*x)
+    return unless @@debug
+    $stdout.puts x
+    $stdout.flush
+  end
+
+  #
+  # Main parsing loop.  We basically parse the file twice to
+  # solve dependencies.  Yes, this is inefficient, but the alternative
+  # was to build a full parser that understands forward dependencies.
+  #
+  def parse(file)
+    # We start map at 0, 0
+    @x, @y = [0, 0]
+    @room  = nil
+
+    if @map.kind_of?(FXMap)
+      @map.options['Edit on Creation'] = false
+      @map.window.hide
+    end
+    @map.section = 0
+
+    @parsing      = nil
+    @last_section = 0
+    @ignore_first_section = true
+    @room_idx = 0
+    line_number = 0
+
+    debug "...Parse... #{file.path}"
+    while not file.eof?
+      @line = ''
+      while not file.eof? and @line == ''
+	@line << file.readline()
+	@line.sub!( /^\s*!.*$/, '')
+	line_number += 1
+      end
+      # Remove comments at end of line
+      @line.sub!( /\s+![^"]*$/, '')
+      # Remove starting spaces (if any)
+      @line.sub! /^\s+/, ''
+      # Replace \n with simple space
+      @line.gsub! /\n/, ' '
+      next if @line == ''
+      full_line = @line.dup
+      begin
+	parse_line
+      rescue ParseError => e
+	$stderr.puts
+	$stderr.puts "#{e} at #{file.path}, line #{line_number}:"
+	$stderr.puts ">>>> #{full_line};"
+	$stderr.puts
+      end
+    end
+    debug "...End Parse..."
+  end
+
+
+  CLASS     = /^class\s+(\w+)/i
+  DOOR      = /(?:^|\s+)door_to(?:\s+([^,;]*)|$)/i
+  INCLUDE   = /^#?include\s+"([^"]+)"/i
+  PLAYER_TO = /\bplayerto\((\w+)/i
+
+
+  STD_LIB = [
+    'Parser',
+    'VerbLib',
+    'Grammar'
+  ]
+
+
+  def find_file(file)
+    return file if File.exists?(file)
+    @include_dirs.each { |d|
+      [ "#{d}/#{file}",
+	"#{d}/#{file}.h",
+	"#{d}/#{file}.inf", ].each { |full|	
+	return full if File.exists?(full)
+      }
+    }
+    return nil
+  end
+
+  #
+  # Parse a line of file
+  #
+  def parse_line
+    if @line =~ INCLUDE
+      name = $1
+      unless STD_LIB.include?(name)
+	file = find_file(name)
+	if file
+	  File.open(file, 'r') { |f| parse(f) }
+	else
+	  raise ParseError, "Include file #{name} not found"
+	end
+      end
+    end
+
+    if @line =~ CLASS
+      @clas = $1
+      debug "CLASS: #@clas"
+      if @classes.has_key?(@clas)
+	if @obj
+	else
+	end
+      else
+	@classes[@clas] = {}
+	@tag = @name = nil
+      end
+    end
+
+    re = /^(#{@classes.keys.join('|')})(\s+->)?(\s+(\w+))?(\s+"([^"]+)")?(\s+(\w+))?/
+    if @line =~ re
+      @clas = $1
+      prev  = $2
+      @tag  = $4 || $6
+      @name = $6
+
+      loc  = $8
+      if prev and @room
+	loc = @room.tag 
+      end
+
+      debug <<"EOF"
+CURRENT ROOM:#@room
+Class   : #@clas
+Tag     : #@tag
+Name    : #@name
+Location: #{loc}  #{loc.class}
+EOF
+
+      @obj = nil
+
+      c = @classes[@clas]
+      if c[:door]
+	@obj = InformDoor.new
+	@obj.tag = @tag
+	@tags[@tag] = @obj
+	@doors << @obj
+	debug "+++ DOOR"
+      elsif loc or c[:scenery] or c[:static]
+	debug "+++ OBJECT"
+	if @tag
+	  @obj = InformObject.new()
+	  @obj.tag  = @tag
+	  @obj.name = @name
+	  @obj.location << loc
+	  @tags[@tag] = @obj
+	  @objects << @obj
+	end
+      else
+	debug "+++ ROOM?"
+	@obj = @room = nil
+	if @tag and @name
+	  # We assume we are a room (albeit we could be an obj)
+	  @room = InformRoom.new
+	  @room.tag   = @tag
+	  @room.name  = @name
+	  @room.darkness = !c[:light]
+	  @tags[@tag] = @room
+	  @rooms << @room
+	end
+      end
+      @before = false
+      @go     = false
+
+    end
+
+    if @line =~ NAME
+      # We have an object.  Delete last room we created, as it is not one.
+      @rooms.delete_if { |r| r.tag == @tag }
+      @obj = InformObject.new()
+      @obj.tag  = @tag
+      @obj.name = @name
+      @tags[@tag] = @obj
+      @objects << @obj
+    end
+
+    if @line =~ FUNCTION
+      @functions << $1
+    end
+
+    dirs = @line.scan(DIR_TO) + @line.scan(DIR) + @line.scan(ENTER_DIR)
+    if dirs.size > 0
+      dirs.each { |d, room|
+	dir = DIRECTIONS[d]
+	@room.exits[dir] = room
+      }
+    end
+
+    if @line =~ /\bbefore\b/i
+      @before = true
+    end
+
+    if @line =~ /\bgo\s*:/i and @room and @before
+      if @line =~ GO_OBJ
+	dir = DIRECTIONS[$1]
+	if @line =~ PLAYER_TO
+	  @room.exits[dir] = $1
+	end
+      end
+    end
+
+    if @obj.kind_of?(InformObject) and @before
+      if @line =~ PLAYER_TO
+	@obj.enterable << $1
+      end
+    end
+
+    if @tag and @line =~ DOOR
+      door = InformDoor.new
+      door.location  = $1.split(' ')
+      door.location += @obj.location if @obj
+      door.tag = @tag
+      @obj = door
+      @tags[@tag] = door
+      @doors << door
+      @objects.delete(@obj) if @obj and @obj.tag == @tag
+    end
+
+    if @line =~ /\bhas\s+([^,;]+)[,;]/i
+      props = $1.split
+      props.each { |p|
+	if not @tag
+	  if p[0,1] == '~'
+	    @classes[@clas][p[1,-1].to_sym] = false
+	  else
+	    @classes[@clas][p.to_sym] = true
+	  end
+	else
+	  if p =~ /locked/ and @doors.size > 0
+	    @doors[-1].locked = true
+	  end
+	  if p =~ /(static|scenery)/ and @obj
+	    @objects.delete(@obj)
+	  end
+	  if @room and p =~ /(\~)?light/
+	    dark = ($1 == '~')
+	    @room.darkness = dark
+	  end
+	end
+      }
+    end
+
+    if @line =~ /\bfound_in\s+(.*)[,;]?/
+      if not @obj
+	puts '-' * 78
+	puts "#@name -> obj not defined " 
+	puts '-' * 78
+      else
+	locs = $1.split
+	@obj.location = locs
+	debug "#{@obj} #{@obj.location} FOUND_IN: #{locs.join(' ')}"
+      end
+    end
+  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 for #{room}."
+    end
+  end
+
+
+  def oneway_link?(a, b)
+    # First, check if room already has exit moving towards other room
+    a.exits.each_with_index { |e, idx|
+      next if not e or e.dir != Connection::AtoB
+      roomA = e.roomA
+      roomB = e.roomB
+      if roomA == a and roomB == b
+	return e
+      end
+    }
+    return nil
+  end
+
+
+  # Choose a direction to represent up/down/in/out.
+  def choose_dir(a, b, go = nil, exitB = nil)
+    if go
+      rgo = go % 2 == 0? go - 1 : go + 1
+      # First, check if room already has exit moving towards other room
+      a.exits.each_with_index { |e, idx|
+	next if not e or e.stub?
+	roomA = e.roomA
+	roomB = e.roomB
+	if roomA == a and roomB == b
+	  e.exitAtext = go
+	  return idx
+	elsif roomB == a and roomA == b
+	  e.exitBtext = go
+	  return idx
+	end
+      }
+    end
+
+    # We prefer directions that travel less... so we need to figure
+    # out where we start from...
+    if b
+      x = b.x
+      y = b.y
+    else
+      x = a.x
+      y = a.y
+    end
+    if exitB
+      dx, dy = Room::DIR_TO_VECTOR[exitB]
+      x += dx
+      y += dy
+    end
+
+    # No such luck... Pick a direction.
+    best = nil
+    bestscore = nil
+
+    DIRLIST.each { |dir|
+      # We prefer straight directions to diagonal ones
+      inc   = dir % 2 == 1 ? 100 : 140
+      score = 1000
+      # We prefer directions where both that dir and the opposite side
+      # are empty.
+      if (not a[dir]) or a[dir].stub?
+	score += inc
+	score += 4 if a[dir] #attaching to stubs is better
+      end
+#       rdir  = (dir + 4) % 8
+#       score += 1   unless a[rdir]
+
+      # Measure distance for that exit, we prefer shorter
+      # paths
+      dx, dy = Room::DIR_TO_VECTOR[dir]
+      dx = (a.x + dx) - x
+      dy = (a.y + dy) - y
+      d = dx * dx + dy * dy
+      score -= d
+      next if bestscore and score <= bestscore
+      bestscore = score
+      best = dir
+    }
+
+    if not bestscore
+      raise "No free exit for choose_dir"
+    end
+
+    return best
+  end
+
+  def new_room(from, to, x, y, dx = 1, dy = 0 )
+    elem = @tags[to.tag]
+    if elem.kind_of?(InformRoom)
+      if not @map.free?(x, y)
+	@map.shift(x, y, dx, dy)
+      end
+      room = @map.new_room(x, y)
+      room.name     = to.name
+      room.darkness = to.darkness
+      @tags[to.tag] = room
+      return [room, Connection::FREE]
+    elsif elem.kind_of?(InformDoor)
+      if elem.locked
+	type = Connection::LOCKED_DOOR
+      else
+	type = Connection::CLOSED_DOOR
+      end
+
+      @rooms.each { |o|
+	next if @tags[o.tag] == from
+	o.exits.each { |e|
+	  next unless e
+	  if @tags[e] == elem
+	    res = new_room( o, o, x, y, dx, dy )
+	    return [ res[0], type ]
+	  end
+	}
+      }
+
+      # Okay, connecting room is missing.  Check door's locations property
+      p elem.location
+      elem.location.each { |tag|
+	next if @tags[tag] == from
+	@rooms.each { |o|
+	  next if o.tag != tag
+	  res = new_room( o, o, x, y, dx, dy )
+	  return [ res[0], type ]
+	}
+      }
+      
+      #raise "error: no room with door #{to.name} #{elem.name}"
+      return [nil, nil]
+    else
+      return [elem, Connection::FREE]
+    end
+  end
+
+  def create_room(r, x, y, dx = 1, dy = 0)
+    from, = new_room(r, r, x, y)
+    debug "CREATE ROOM #{r.name} SET FROM TO: #{from}"
+
+    r.exits.each_with_index { |e, exit|
+      next unless e
+      next if e == 'nothing'
+      debug "#{r.name} EXIT:#{exit} points to #{e}"
+
+      to = @tags[e]
+      if not to
+	next if @functions.include?(e)
+	raise "Room #{e} #{e.class} not found." if not to
+      end
+
+      go = c = nil
+
+      dir  = exit
+      type = 0
+
+      # If exit leads to an enterable object, find out where does that
+      # enterable object lead to.
+      if to.kind_of?(InformObject)
+	rooms = to.enterable
+	rooms.each { |room|
+	  next if room == r
+	  to = @tags[room]
+	  break
+	}
+	# Skip it if we are still an object.  This means we are just
+	# a container, like the phone booth in the Fate game demo.
+	next if to.kind_of?(InformObject)
+      end
+
+      if to.kind_of?(InformRoom) or to.kind_of?(InformDoor)
+	if dir > 7
+	  # choose a dir for up/down/in/out
+	  go = dir - 7
+	  dir = choose_dir(from, nil, go)
+	end
+
+	dx, dy = Room::DIR_TO_VECTOR[dir]
+	x = from.x + dx
+	y = from.y + dy
+	debug "#{exit} CREATE TO #{from} -> #{to.tag}"
+	to, type = new_room(from, to, x, y, dx, dy)
+	next if not to
+	puts  "---- back: #{to.name} #{to.class}"
+      else
+	if dir > 7
+	  # choose a dir for up/down/in/out
+	  go = dir - 7
+	  dir = choose_dir(from, to, go)
+	end
+      end
+
+      odir = (dir + 4) % 8
+
+      if from[dir]
+	c = from[dir]
+	if to[odir] == c and c.roomB == from
+	  debug "LINK TRAVELLED BOTH"
+	  c.dir = Connection::BOTH
+	  c.exitBtext = go if go
+	  next
+	else
+	  debug "#{exit} FROM #{from}->#{to} BLOCKED DIR: #{dir}"
+	  shift_link(from, dir)
+	end
+      end
+
+      # Check we don't have a connection already
+      if to[odir]
+	c = to[odir]
+	debug "#{from} #{dir} -> #{to} dir:#{odir} filled.  Swap..."
+
+	# We need to change odir to something else
+	rgo = 0
+	if go
+	  rgo = go % 2 == 0? go - 1 : go + 1
+	end
+
+	# First, check if we have a dangling one-way link going to->from
+	# If we do, we use it.
+	c = oneway_link?(from, to)
+	if not c
+	  odir = choose_dir(to, from, rgo, dir)
+	  debug "Swapped to #{odir}"
+	else
+	  debug "FOUND LINK #{c} -- filling it."
+	  idx = from.exits.index(c)
+	  from[idx] = nil
+	  from[dir] = c
+	  c.dir = Connection::BOTH
+	  c.exitBtext = go
+	end
+      else
+	debug "to[odir] empty."
+	# First, check if we have a dangling one-way link going to->from
+	# If we do, we use it.
+	c = oneway_link?(to, from)
+	if c
+	  debug "FOUND LINK #{c} -- filling it."
+	  idx = from.exits.index(c)
+	  from[idx] = nil
+	  from[dir] = c
+	  c.dir = Connection::BOTH
+	  c.exitBtext = go if go
+	end
+      end
+
+      if not c
+	debug "NEW LINK #{from} #{dir} to #{to} #{odir}"
+	begin
+	  c     = @map.new_connection(from, dir, to, odir)
+	  c.exitAtext = go if go
+	  c.dir = Connection::AtoB
+	  c.type = type
+	rescue Section::ConnectionError
+	end
+      end
+    }
+
+    return r
+  end
+
+  #
+  # Create all the stuff we found
+  #
+  def create
+    @rooms.each { |r| create_room(r, 0, 0) }
+    @rooms = []
+    
+    # Add objects to rooms
+    @objects.each { |obj|
+      obj.location.each { |loc|
+	r = @tags[loc]
+	next unless r and r.kind_of?(Room)
+	r.objects << obj.name + "\n"
+      }
+    }
+  end
+
+
+  if RUBY_PLATFORM =~ /win/
+    SEP = ';'
+  else
+    SEP = ':'
+  end
+
+  #
+  # Bring up the Inform properties window, to allow user to change
+  # settings
+  #
+  def properties
+    decor = DECOR_TITLE|DECOR_BORDER
+
+    dlg = FXDialogBox.new( @map.window.parent, "Inform Settings", decor )
+    mainFrame = FXVerticalFrame.new(dlg,
+				    FRAME_SUNKEN|FRAME_THICK|
+				    LAYOUT_FILL_X|LAYOUT_FILL_Y)
+
+    frame = FXHorizontalFrame.new(mainFrame, LAYOUT_SIDE_TOP|LAYOUT_FILL_X)
+
+    FXLabel.new(frame, "Include Dirs: ", nil, 0, LAYOUT_FILL_X)
+    inc = FXTextField.new(frame, 80, nil, 0, LAYOUT_FILL_ROW)
+    inc.text = @include_dirs.join(SEP)
+
+    buttons = FXHorizontalFrame.new(mainFrame, 
+				    LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|
+				    PACK_UNIFORM_WIDTH)
+    # Accept
+    FXButton.new(buttons, "&Accept", nil, dlg, FXDialogBox::ID_ACCEPT,
+		 FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y)
+    
+    # Cancel
+    FXButton.new(buttons, "&Cancel", nil, dlg, FXDialogBox::ID_CANCEL,
+		 FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y)
+    if dlg.execute != 0
+      @include_dirs = inc.text.split(SEP)
+      return true
+    end
+    return false
+  end
+
+
+
+  def set_include_dirs
+    # Try to find inform(.exe) in path.
+    paths = ENV['PATH'].split(SEP)
+    paths.each { |p|
+      next if not File.directory?(p)
+      Dir.foreach(p) { |x|
+ 	if x =~ /^inform(.exe)?$/i
+	  @include_dirs << p
+	  @include_dirs << p + "/Base"
+	  @include_dirs << p + "/Contrib"
+	  @include_dirs << p + "/../Contrib"
+	  break
+	end
+      }
+    }
+  end
+
+  def initialize(file, map = Map.new('Inform Map'))
+    debug "Initialize"
+    @classes = { 'Object' => {} }
+    @tags    = {}
+    @map     = map
+    @objects = []
+    @doors   = []
+    @functions = []
+    @rooms   = []
+
+    @include_dirs = [File.dirname(file)]
+    set_include_dirs
+
+
+    debug "Get properties"
+    if @map.kind_of?(FXMap)
+      return unless properties
+    end
+
+    debug "Start parsing #{file}"
+    File.open(file) { |f|
+      parse(f)
+    }
+    debug "Done parsing #{file}"
+    debug "Rooms: #{@rooms.size}"
+    debug "Doors: #{@doors.size}"
+    debug "Objects: #{@objects.size}"
+
+    create
+    debug "Done creating #{file}"
+
+    if @map.kind_of?(FXMap)
+      @map.filename   = file.sub(/\.inf$/i, '.map')
+      # @map.navigation = true
+      @map.modified   = false
+      @map.window.show
+    end
+    @objects   = nil
+    @tags      = nil   # save some memory by clearing the tag list
+    @rooms     = nil   # and room list
+  end
+end
+
+
+if $0 == __FILE__
+  p "Opening file '#{ARGV[0]}'"
+  BEGIN { 
+    $LOAD_PATH << 'C:\Windows\Escritorio\IFMapper\lib'
+  }
+
+  require "IFMapper/Map"
+  InformReader.new(ARGV[0])
+end