ifmapper 0.8.5 → 0.9

data/lib/IFMapper/FXMapFileDialog.rb

@@ -8,7 +8,7 @@ class FXMapFileDialog < FXFileDialog
   @@last_path = nil
 
   KNOWN_EXTENSIONS = [
-    "Map Files (*.map,*.ifm)",
+    "Map Files (*.map,*.ifm,*.inf,*.t)",
     "All Files (*)",
   ]
 

data/lib/IFMapper/FXMapperSettings.rb

@@ -34,7 +34,9 @@ class FXMapperSettings < Hash
       f = home + '/.ifmapper'
       self.replace( YAML.load_file(f) )
     rescue
-      self.replace( {
+    end
+
+    defaults = {
 		     # Colors
 		     'BG Color'           => 'dark grey',
 		     'Arrow Color'        => 'black',
@@ -51,15 +53,23 @@ class FXMapperSettings < Hash
 		     'Create on Connection' => true,
 		     'Edit on Creation'     => false,
 		     'Automatic Connection' => true,
-		     
+
+
 		     # Display options
 		     'Use Room Cursor'      => false,
 		     'Paths as Curves'      => true,
-		     'Location Numbers'     => true,
+
+                     # Location options
+                     'Location Tasks'           => true,
+                     'Location Description'     => false,
+		     'Location Numbers'         => true,
+
+                     # Grid options
 		     'Grid Boxes' => true,
 		     'Grid Straight Connections' => true,
 		     'Grid Diagonal Connections' => false,
-		   } )
-    end
+		 }
+
+    self.replace( defaults.merge(self) )
   end
 end

data/lib/IFMapper/FXMapperWindow.rb

@@ -40,7 +40,7 @@ require 'IFMapper/FXMapColorBox'
 class FXMapperWindow < FXMainWindow
 
   PROGRAM_NAME = "Interactive Fiction Mapper"
-  VERSION      = '0.8.5'
+  VERSION      = '0.9'
   AUTHOR       = "Gonzalo Garramuno"
   TITLE = "#{PROGRAM_NAME} v#{VERSION} - Written by #{AUTHOR}"
 
@@ -66,6 +66,17 @@ class FXMapperWindow < FXMainWindow
     return map
   end
 
+  def open_tads(file, map)
+    require 'IFMapper/TADSReader'
+    TADSReader.new(file, map)
+    return map
+  end
+
+  def open_inform(file, map)
+    require 'IFMapper/InformReader'
+    InformReader.new(file, map)
+    return map
+  end
 
   def start_automap_cb(sender, sel, ptr)
     map = current_map
@@ -116,6 +127,10 @@ class FXMapperWindow < FXMainWindow
     tmp = nil
     if file =~ /\.ifm$/i
       tmp = open_ifm(file, map)
+    elsif file =~ /\.inf$/i
+      tmp = open_inform(file, map)
+    elsif file =~ /\.t$/i
+      tmp = open_tads(file, map)
     else
       tmp = open_map(file)
     end
@@ -131,12 +146,11 @@ class FXMapperWindow < FXMainWindow
     end
     
     map.copy(tmp)
-    map.fit
-    map.create_pathmap
+    map.options.replace( @@default_options.merge(map.options) )
     map.verify_integrity
+    map.fit
     map.window.create
-    map.update_title
-    map.draw
+    map.modified = false
     update_section
     status "Loaded '#{file}'."
   end
@@ -260,6 +274,41 @@ class FXMapperWindow < FXMainWindow
     end
   end
 
+  def inform_export_cb(sender, sel, msg)
+    map = current_map
+    return unless map
+
+    require 'IFMapper/InformWriter'
+
+    d = FXMapFileDialog.new(self, "Save Map as Inform Files", 
+			    [
+			      "Inform Source Code (*.inf)"
+			    ])
+    if d.filename != ''
+      file  = d.filename
+      file.sub!(/(-\d+)?\.inf/, '')
+      InformWriter.new(map, file)
+    end
+  end
+
+
+  def tads_export_cb(sender, sel, msg)
+    map = current_map
+    return unless map
+
+    require 'IFMapper/TADSWriter'
+
+    d = FXMapFileDialog.new(self, "Save Map as TADS Files", 
+			    [
+			      "TADS Source Code (*.t)"
+			    ])
+    if d.filename != ''
+      file  = d.filename
+      file.sub!(/(-\d+)?\.t/, '')
+      TADSWriter.new(map, file)
+    end
+  end
+
 
   def pdf_export_cb(sender, sel, msg)
     map = current_map
@@ -353,7 +402,7 @@ class FXMapperWindow < FXMainWindow
 
   def self.cut_selected(map)
     FXMapperWindow::copy_selected(map)
-    map.delete_selected
+    map.cut_selected
   end
 
   def self.paste_selected(map)
@@ -401,8 +450,18 @@ class FXMapperWindow < FXMainWindow
 	  exitB = c.roomB.exits.rindex(c)
 	  roomA = r_to_nr[c.roomA]
 	  roomB = r_to_nr[c.roomB]
-	  c = map.new_connection(roomA, exitA, roomB, exitB)
-	  c.selected = true
+	  next if not roomA or not roomB
+	  if not exitA
+	    puts "WHOA!  #{c}  #{roomA} #{exitA} is empty"
+	    next
+	  end
+	  begin
+	    c = map.new_connection(roomA, exitA, roomB, exitB)
+	    c.selected = true
+	  rescue Section::ConnectionError => e
+	    puts c
+	    puts e
+	  end
 	}
       end
 
@@ -659,6 +718,13 @@ EOF
 
     cmd = FXMenuCommand.new(submenu, "&Export as IFM...\t\tExport map as an IFM map.", nil)
     cmd.connect(SEL_COMMAND, method(:ifm_export_cb))
+
+    cmd = FXMenuCommand.new(submenu, "&Export as Inform Source...\t\tExport map as an Inform source code file.", nil)
+    cmd.connect(SEL_COMMAND, method(:inform_export_cb))
+
+    cmd = FXMenuCommand.new(submenu, "&Export as TADS3 Source...\t\tExport map as a TADS3 source code file.", nil)
+    cmd.connect(SEL_COMMAND, method(:tads_export_cb))
+
     FXMenuCascade.new(filemenu, "Export", nil, submenu)
 
 
@@ -873,6 +939,34 @@ EOF
       s.check = map.options['Location Numbers'] if map
     }
 
+    cmd = FXMenuCheck.new(submenu, "Location Tasks\t\tShow Tasks in Location Edit Box.")
+    cmd.check = @@default_options['Location Tasks']
+    cmd.connect(SEL_COMMAND) { |s, m, e|
+      map = current_map
+      if map
+	map.options['Location Tasks'] = (s.check == true)
+	map.draw
+      end
+    }
+    cmd.connect(SEL_UPDATE) { |s, m, e|
+      map = current_map
+      s.check = map.options['Location Tasks'] if map
+    }
+
+    cmd = FXMenuCheck.new(submenu, "Location Description\t\tShow Description in Location Edit Box.")
+    cmd.check = @@default_options['Location Description']
+    cmd.connect(SEL_COMMAND) { |s, m, e|
+      map = current_map
+      if map
+	map.options['Location Description'] = (s.check == true)
+	map.draw
+      end
+    }
+    cmd.connect(SEL_UPDATE) { |s, m, e|
+      map = current_map
+      s.check = map.options['Location Description'] if map
+    }
+
     cmd = FXMenuCheck.new(submenu, "Boxes\t\tDraw dashed box guidelines.")
     cmd.check = @@default_options['Grid Boxes']
     cmd.connect(SEL_COMMAND) { |s, m, e|

data/lib/IFMapper/FXRoom.rb

@@ -50,7 +50,7 @@ class FXRoom < Room
   # the room data over to it.
   #
   def selected=(value)
-    if value and @@win
+    if value and @@win and @@win.shown?
       @@win.copy_from(self)
     end
     @selected = value
@@ -65,7 +65,6 @@ class FXRoom < Room
       @@win.hide
     end
     win = FXRoomDialogBox.new(map, self, nil, true)
-    # win.setFocus
     win.setFocus
     win.show
     win.copy_from(self)
@@ -83,7 +82,6 @@ class FXRoom < Room
   def update_properties(map)
     return if not @@win or not @@win.shown?
     @@win.map = map
-    @@win.setFocus
     @@win.copy_from(self)
   end
 

data/lib/IFMapper/FXRoomDialogBox.rb

@@ -13,39 +13,59 @@ class FXRoomDialogBox < FXDialogBox
     @room.objects.gsub!(/[\.,\t]+/, "\n")
     @room.tasks = @tasks.text
     @room.darkness = (@darkness.checkState == 1)
+    @room.desc = @desc.text
 
-    ## we should do something like:
-    ## @room.draw(dc)
-    ## for faster updates
-    @map.draw
+    @map.draw_room(@room)
   end
 
 
   def copy_from(room)
+    @room                = room
     @name.text           = room.name
     @darkness.checkState = room.darkness
     @objects.text        = room.objects
     @tasks.text          = room.tasks
+    @desc.text           = room.desc
+
     # Select text for quick editing if it uses default location name
-    @name.setCursorPos room.name.size # - 1 if room.name.size > 0
+    @name.setCursorPos room.name.size 
     if room.name == 'New Location'
+      self.setFocus
       @name.selectAll
-    end
-    if self.shown?
       @name.setFocus
     end
-    @room = room
     if @map.navigation
       @name.disable
       @darkness.disable
       @objects.disable
       @tasks.disable
+      @desc.disable
     else
       @name.enable
       @darkness.enable
       @objects.enable
       @tasks.enable
+      @desc.enable
+    end
+
+    if @map.options['Location Tasks']
+      @tasksFrame.show
+    else
+      @tasksFrame.hide
+    end
+    if @map.options['Location Description']
+      @descFrame.show
+    else
+      @descFrame.hide
     end
+
+    @desc.connect(SEL_CHANGED) { @room.desc = @desc.text }
+
+    # Yuck!  Fox's packer is absolutely oblivious to hiding/showing of
+    # elements, so we need to force a dummy resize so the layout is
+    # recalculated.  But FUCK!  This completely fucks up the focus.
+    # Fox is a piece of ****.  I **REALLY** need to go back to FLTK.
+    ##  self.resize(self.defaultWidth, self.defaultHeight)
   end
 
   def initialize(map, room, event = nil, modal = nil)
@@ -74,24 +94,39 @@ class FXRoomDialogBox < FXDialogBox
     FXLabel.new(frame, "Location: ", nil, 0, LAYOUT_FILL_X)
     @name = FXTextField.new(frame, 40, nil, 0, LAYOUT_FILL_ROW)
 
-    frame = FXVerticalFrame.new(mainFrame, 
+
+    all = FXHorizontalFrame.new(mainFrame,
 				LAYOUT_SIDE_TOP|LAYOUT_FILL_X|LAYOUT_FILL_Y)
 
-    
-    frame2 = FXHorizontalFrame.new(frame, LAYOUT_SIDE_TOP|LAYOUT_FILL_X)
+    leftFrame = FXVerticalFrame.new(all, 
+				    LAYOUT_SIDE_TOP|LAYOUT_SIDE_LEFT|
+				    LAYOUT_FILL_X|LAYOUT_FILL_Y)
+
+    frame2 = FXHorizontalFrame.new(leftFrame, LAYOUT_SIDE_TOP|LAYOUT_FILL_X)
     FXLabel.new(frame2, "Objects: ", nil, 0, LAYOUT_FILL_X)
     @darkness = FXCheckButton.new(frame2, "Darkness", nil, 0,
 				  ICON_BEFORE_TEXT|LAYOUT_CENTER_X|
 				  LAYOUT_SIDE_RIGHT)
 
-    @objects = FXText.new(frame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y)
+    @objects = FXText.new(leftFrame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y)
     @objects.visibleRows = 8
+    @objects.visibleColumns = 40
 
-    frame = FXVerticalFrame.new(mainFrame, LAYOUT_SIDE_TOP|LAYOUT_FILL_X|
-				LAYOUT_FILL_Y)
-    FXLabel.new(frame, "Tasks: ", nil, 0, LAYOUT_FILL_X)
-    @tasks = FXText.new(frame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y)
+    @tasksFrame = FXVerticalFrame.new(leftFrame, LAYOUT_SIDE_TOP|LAYOUT_FILL_X|
+				     LAYOUT_FILL_Y)
+    FXLabel.new(@tasksFrame, "Tasks: ", nil, 0, LAYOUT_FILL_X)
+    @tasks = FXText.new(@tasksFrame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y)
     @tasks.visibleRows = 8
+    @tasks.visibleColumns = 40
+
+    ######## Add description
+    @descFrame = FXVerticalFrame.new(all, LAYOUT_SIDE_TOP|LAYOUT_FILL_X|
+				LAYOUT_SIDE_RIGHT|LAYOUT_FILL_Y)
+    FXLabel.new(@descFrame, "Description: ", nil, 0, LAYOUT_FILL_X)
+    @desc = FXText.new(@descFrame, nil, 0, 
+		       LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP)
+    @desc.visibleColumns = 70
+    @desc.visibleRows = 18
 
     if modal
       buttons = FXHorizontalFrame.new(mainFrame, 
@@ -109,6 +144,7 @@ class FXRoomDialogBox < FXDialogBox
       @objects.connect(SEL_CHANGED) { copy_to()}
       @tasks.connect(SEL_CHANGED) { copy_to() }
       @darkness.connect(SEL_COMMAND) { copy_to() }
+      @desc.connect(SEL_CHANGED) { @room.desc = @desc.text }
     end
     
     @map = map

data/lib/IFMapper/FXSection.rb

@@ -5,6 +5,15 @@ require 'IFMapper/Section'
 
 class FXSection < Section
   def new_connection( roomA, exitA, roomB, exitB = nil )
+    # Verify rooms exist in section (ie. don't allow links across
+    # sections)
+    if not @rooms.include?(roomA)
+      raise ConnectionError, "Room #{roomA} not in section #{self}"
+    end
+    if roomB and not @rooms.include?(roomB)
+      raise ConnectionError, "Room #{roomB} not in section #{self}"
+    end
+
     c = FXConnection.new( roomA, roomB )
     return _new_connection(c, roomA, exitA, roomB, exitB)
   end

data/lib/IFMapper/IFMReader.rb

@@ -550,17 +550,19 @@ class IFMReader
     @map    = map
     @rooms  = []
     @resolve_tags = false
-    # puts '--------------- first pass'
+
+    # --------------- first pass
     File.open(file) { |f| 
       parse(f)
     }
-    # puts '--------------- second pass'
+
+    # --------------- second pass
     @map.fit
     @resolve_tags = true
     File.open(file) { |f|
       parse(f)
     }
-    # puts '--------------- second pass done'
+
     @map.section = 0
     if @map.kind_of?(FXMap)
       @map.filename   = file.sub(/\.ifm$/i, '.map')

data/lib/IFMapper/InformReader.rb

@@ -0,0 +1,803 @@
+
+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 method_missing(*a)
+    end
+
+    def initialize(location)
+      if location
+	@location = Array[*location]
+      else
+	@location = []
+      end
+      @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, :light, :desc
+    def to_s
+      "#@name tag:#@tag"
+    end
+    def name=(x)
+      @name = InformReader::inform_unquote(x)
+    end
+    def method_missing(*x)
+    end
+    def initialize
+      @desc     = ''
+      @exits    = Array.new(12, nil)
+    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 ]
+
+  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 = nil
+  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
+  DESCRIPTION = /(?:^|\s+)description(?:\s*$|\s+"([^"]+)?("?))/i
+
+  STD_LIB = [
+    'Parser',
+    'VerbLib',
+    'Grammar'
+  ]
+
+
+  def new_room
+    debug "+++ ROOM: #@name"
+    
+    # We assume we are a room (albeit we could be an obj)
+    @room = InformRoom.new
+    @room.tag   = @tag
+    @room.name  = @name
+    @room.desc  = @desc
+    @room.light = @classes[@clas][:light]
+    @tags[@tag] = @room
+    @rooms << @room
+  end
+
+  def new_obj(loc = nil)
+    debug "+++ OBJ #@name"
+    @obj = InformObject.new(loc)
+    @obj.tag  = @tag
+    @obj.name = @name
+    @tags[@tag] = @obj
+    @objects << @obj
+  end
+
+
+  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
+	  @classes[@clas].each { |k, v| @obj.send("#{k}=", v) }
+	elsif @room
+	  @classes[@clas].each { |k, v| @room.send("#{k}=", v) }
+	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
+      @desc = ''
+      @in_desc = false
+
+      loc  = $8
+      if prev and @room
+	loc = @room.tag 
+      end
+
+      debug <<"EOF"
+Name    : #@name
+Class   : #@clas
+Tag     : #@tag
+Location: #{loc}  #{loc.class}
+EOF
+
+      @obj = nil
+
+      c = @classes[@clas]
+      if c[:door]
+	debug "+++ DOOR"
+	@obj = InformDoor.new
+	@obj.tag = @tag
+	@tags[@tag] = @obj
+	@doors << @obj
+      elsif loc or c[:scenery] or c[:static]
+	debug "+++ OBJECT #{loc} #{c[:scenery]}, #{c[:static]}"
+	new_obj(loc) if @tag
+      else
+	@obj = @room = nil
+	new_room if @tag and @name and c.has_key?(:light) 
+      end
+      @before = false
+      @go     = false
+
+    end
+
+    if @in_desc
+      text = @line.scan( /\s*([^"]+)("\s*[,;])?/ )
+      text.each { |t, q|
+	@desc << t
+	@in_desc = nil if q
+      }
+    end
+
+    if @desc and @line =~ DESCRIPTION
+      @desc << $1 if $1
+      @in_desc = true unless $2
+    end
+
+
+    if @line =~ FUNCTION
+      @functions << $1
+    end
+
+    dirs = @line.scan(DIR_TO) + @line.scan(DIR) + @line.scan(ENTER_DIR)
+    if dirs.size > 0
+      new_room if not @room
+      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 =~ /(?:^|\s+)has\s+([\w\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 p =~ /(\~)?light/
+	    new_room if not @room
+	    @room.light = ($1 != '~')
+	  end
+	end
+      }
+    end
+
+    if @line =~ /\bfound_in\s+(.*)[,;]?/
+      if @obj
+	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 make_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
+      desc = to.desc
+      desc.gsub!(/[\t\n]/, ' ')
+      desc.squeeze!(' ')
+      room.desc     = InformReader::inform_unquote(desc)
+      room.darkness = !to.light
+      @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 = make_room( o, o, x, y, dx, dy )
+	    return [ res[0], type ]
+	  end
+	}
+      }
+
+      # Okay, connecting room is missing.  Check door's locations property
+      elem.location.each { |tag|
+	next if @tags[tag] == from
+	@rooms.each { |o|
+	  next if o.tag != tag
+	  res = make_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, = make_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' or e == '0'
+      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 = make_room(from, to, x, y, dx, dy)
+	next if not to
+      end
+
+      if exit > 7
+	# choose a dir for up/down/in/out
+	go = exit - 7
+	dir = choose_dir(from, to, go)
+      end
+
+      b = @rooms.find { |r2| r2.tag == e }
+      odir = nil
+      odir = b.exits.rindex(r.tag) if b
+      odir = (dir + 4) % 8 if not odir or odir > 7
+
+      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 if 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}"
+    puts "Rooms: #{@rooms.size}"
+    puts "Doors: #{@doors.size}"
+    puts "Objects: #{@objects.size}"
+
+    create
+    debug "Done creating #{file}"
+
+    if @map.kind_of?(FXMap)
+      @map.filename   = file.sub(/\.inf$/i, '.map')
+      @map.navigation = true
+      @map.options['Location Description'] = true
+      @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