ifmapper 0.8.5 → 0.9

data/lib/IFMapper/Room.rb

@@ -41,7 +41,10 @@ class Room
     @darkness = vars.shift
     @x        = vars.shift
     @y        = vars.shift
-    @desc     = vars.shift if not vars.empty? and vars[0].kind_of?(String)
+    if not vars.empty? and vars[0].kind_of?(String)
+      @desc     = vars.shift
+      @desc.sub!(/\n/, ' ')
+    end
   end
 
   def marshal_dump

data/lib/IFMapper/Section.rb

@@ -118,6 +118,16 @@ class Section
   # Create a new connection among two rooms thru their exits
   #
   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 = Connection.new( roomA, roomB )
     _new_connection( c, roomA, exitA, roomB, exitB )
   end
@@ -179,9 +189,9 @@ EOF
 
     if roomA[exitA]
       if not @connections.include?(roomA[exitA])
-	raise ConnectionError, "room exit #{exitA} for #{roomA} filled but not in section"
+	raise ConnectionError, "roomA exit #{exitA} for #{roomA} filled but not in section"
       end
-      raise ConnectionError, "room exit #{exitA} for #{roomA} is filled" 
+      raise ConnectionError, "roomA exit #{exitA} for #{roomA} is filled" 
     end
 
     roomA[exitA] = c
@@ -201,7 +211,7 @@ EOF
 
     if roomB and roomB[exitB] and roomB[exitB] != c
       roomA[exitA] = nil
-      raise ConnectionError, "room exit #{exitB} for #{roomB} is filled" 
+      raise ConnectionError, "roomB exit #{exitB} for #{roomB} is filled" 
     end
     roomB[exitB] = c if roomB
 
@@ -209,4 +219,8 @@ EOF
     return c
   end
 
+  def to_s
+    return @name
+  end
+
 end

data/lib/IFMapper/TADSReader.rb

@@ -0,0 +1,832 @@
+
+require "IFMapper/Map"
+
+class FXMap; end
+
+#
+# Class that allows creating a map from an TADS source file.
+#
+class TADSReader
+
+  class ParseError < StandardError; end
+  class MapError < StandardError; end
+
+  # Take a quoted TADS string and return a valid ASCII one, replacing
+  # TADS's special characters.
+  def self.unquote(text)
+    return '' unless text
+    text.gsub!(/\\'/, "'")  # restore quotes
+    text.gsub!(/\\"/, '"')  # restore quotes
+    text.gsub!(/<<.*>>/, '')  # remove embedded functions
+    text.gsub!(/<\/?q>/, '"') # Change quotes
+    return text
+  end
+
+  # Temporary classes used to store inform room information
+  class TADSObject
+    attr_reader   :name
+    attr_accessor :tag, :location, :enterable
+
+    def name=(x)
+      @name = TADSReader::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 TADSDoor
+    attr_accessor :location, :locked, :connector, :tag
+    def method_missing(*x)
+    end
+    def initialize
+      @location = []
+    end
+  end
+
+  class TADSRoom
+    attr_reader   :name
+    attr_accessor :exits, :tag, :light, :desc
+    def to_s
+      "#@name tag:#@tag"
+    end
+    def name=(x)
+      @name = TADSReader::unquote(x)
+    end
+    def method_missing(*x)
+    end
+    def initialize
+      @desc     = ''
+      @light    = true
+      @exits    = Array.new(12, nil)
+    end
+  end
+
+  # TADS 3 directional properties need to be spelled fully
+  DIRECTIONS = { 
+    'north' => 0,
+    'northeast' => 1,
+    'east' => 2,
+    'southeast' => 3,
+    'south' => 4,
+    'southwest' => 5,
+    'west' => 6,
+    'northwest' => 7,
+    'up' => 8,
+    'down' => 9,
+    'in' => 10,
+    'out' => 11
+  }
+
+  FUNCTION = /^\[ (\w+);/
+
+  GO_OBJ = /\b(#{DIRECTIONS.keys.join('|').gsub(/_to/, '_obj')})\s*:/i
+
+  # SINGLE QUOTED STRING
+  SQ = '((?:\\\'|[^\'])+)'
+
+  # DOUBLE QUOTED STRING
+  DQ = '((?:\\\"|[^"])+)'
+
+  # Equal sign (TADS supports C or Pascal-like =)
+  EQ = '\s*(?:=|\:=)\s*'
+
+  # Direction list in order of positioning preference.
+  DIRLIST = [ 0, 4, 2, 6, 1, 3, 5, 7 ]
+
+  DIR_TO    = /(?:^|\s+)(#{DIRECTIONS.keys.join('|')})#{EQ}/
+  DIR       = /(?:^|\s+)(#{DIRECTIONS.keys.join('|')})#{EQ}(\w+)/
+  ENTER_DIR = //i # needed?
+
+  OBJLOCATION = /(?:^|\s+)(?:(?:destination|location)#{EQ}(\w+)|@(\w+)|locationList#{EQ}\[([\w\s,]+)\])/
+  OBJNAME     = /(?:^|\s+)name#{EQ}'#{SQ}'/
+  CONNECTOR   = /(?:^|\s+)room\d+\s*#{EQ}\s*(\w+)/
+  ROOMNAME    = /(?:^|\s+)roomName#{EQ}'#{SQ}'/
+  DESCRIPTION = /(?:^|\s+)desc#{EQ}(?:\s*$|\s+"#{DQ}?("?))/
+
+  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
+      # todo: Remove multi-line comments
+      # 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+)\s*:\s*([\w,\s]+)/i
+  DOOR        = /(?:^|\s+)door_to(?:\s+([^,;]*)|$)/i
+  INCLUDE     = /^#include\s+[<"]([^">]+)[">]/
+
+  STD_LIB = [
+    'adv3.h',
+    'en_us.h',
+  ]
+
+
+  def new_room
+    # We assume we are a room (albeit we could be an obj)
+    @room = TADSRoom.new
+    @room.tag   = @tag
+    @room.name  = @name
+    @room.desc  = @desc
+    @tags[@tag] = @room
+    @rooms << @room
+  end
+
+  def new_obj(loc = nil)
+    debug "+++ OBJECT #@name"
+    @obj = TADSObject.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
+
+  def get_parent_classes(clist)
+    ret = []
+    clist.each { |c|
+      c.strip!
+      if @classes[c]
+	ret += get_parent_classes(@classes[c])
+      else
+	ret << c
+      end
+    }
+    return ret
+  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
+      inherits = $2
+      debug "CLASS: #@clas : #{inherits}"
+      @classes[@clas] = inherits.split(/\s*,\s*/)
+      @tag = @name = nil
+      return
+    end
+
+    
+
+    #
+    # Handle room description
+    #
+    if @in_desc == 1 and @line =~ /\s*"#{DQ}("\s*)?/
+      # check for possible start description
+      @room.desc << $1
+      if $2
+	@in_desc = nil
+      else
+	@in_desc = 2
+      end
+      return
+    end
+
+    if @in_desc == 2
+      @line =~ /\s*#{DQ}?("\s*)?/
+      @room.desc << $1 if @room and $1
+      @in_desc = nil if $2
+      return
+    end
+
+
+    # TADS3 definition is like:
+    #  [+] [TAG:] Classes ['adjective nouns'] 'Name' @location
+    plus = '\s*([\+]+\s*)?'
+    tag  = '(?:(\w+)\s*:)?\s*'
+    cls  = '([\w\s\-\>,]+)'
+    noms = "(?:\'#{SQ}\'\s+)?"
+    name = "(?:\'#{SQ}\')?"
+    loc  = '\s+(?:@(\w+))?'
+    re = /^#{plus}#{tag}#{cls}#{noms}#{name}#{loc}/
+    if @line =~ re
+
+      prev  = $1
+      @name = [$5, $4]
+      @tag  = $2
+      @clas = $3  # can be several classes
+      @in_desc = false
+
+
+      loc  = $6
+      if prev and @room
+	loc = @room.tag
+      end
+
+      ## For user classes, flatten inheritance
+      clist = @clas.split(/(?:\s*,\s*|\s)/)
+      flist = get_parent_classes(clist)
+      @clas = flist.join(' ')
+
+      if @clas =~ /\b(Outdoor|Dark)?Room\b/
+	@obj = nil
+	@name = @name[1] || @name[0] || @tag
+	debug "+++ ROOM #@name TAG: #@tag"
+	@tag  = @name if not @tag
+	@desc = ''
+	new_room
+	@room.light = false if $1 == 'Dark'
+	@in_desc = 1
+      elsif @clas =~ /\bFakeConnector\b/
+	@functions << @tag
+      elsif @clas =~ /\bRoomConnector\b/
+	debug "+++ CONNECTOR TAG: #@tag"
+	@desc = ''
+	@obj = TADSDoor.new
+	@obj.connector = true
+	@obj.tag = @tag
+	@tags[@tag] = @obj
+	@doors << @obj
+      elsif @clas =~ /\b(?:(?:Hidden|Secret)?Door|ThroughPassage|Stairway(?:Up|Down))\b/
+	@desc = ''
+	@name = @name[0] || @name[1]
+	@tag  = @name if not @tag
+	debug "+++ DOOR #@tag"
+	if @clas =~ /\s+->\s*(\w+)/
+	  debug "\tmatching side: #{@tag} -> #$1"
+	  # this is the other side of the door... find matching side
+	  @obj = @tags[$1]
+	  if not @obj
+	    @obj = TADSDoor.new
+	    @obj.tag  = @tag
+	    @tags[$1] = @obj
+	  end
+	  @tags[@tag] = @obj
+	  @obj.location << loc if loc
+	else
+	  @obj = @tags[@tag] || TADSDoor.new
+	  @obj.locked = true if @clas =~ /\bLockable(WithKey)?\b/
+	  @obj.tag = @tag
+	  @obj.location = [loc] if loc
+	  @tags[@tag] = @obj
+	  @doors << @obj
+	end
+      elsif @clas =~ /\b(?:Thing|Food|Person)\b/
+	@obj = nil
+	@desc = ''
+	@name = @name[0] || @name[1]
+	@tag  = @name if not @tag
+	new_obj(loc) if @tag
+      else
+	@name = (@name[0] || @name[1] || @tag)
+      end
+
+#       debug <<"EOF"
+# Name: #@name
+# 	Classes : #@clas
+# 	Tag     : #@tag
+# 	Location: #{loc}  #{loc.class}
+# EOF
+
+
+    end
+
+    if @obj
+      @obj.name      = $1 if @line =~ OBJNAME
+      if @line =~ OBJLOCATION
+	if $1
+	  locs = $1.split(/\s*,\s*/)
+	  @obj.location += locs
+	end
+      end
+      @obj.location << $1 if @obj.connector and @line =~ CONNECTOR
+    end
+
+    if @room and @line =~ ROOMNAME
+      @room.name = $1
+      return
+    end
+
+    if @line =~ DESCRIPTION
+      @desc << $1 if @desc and $1
+      @in_desc = 2 if $2 == ''
+    end
+
+    dirs = @line.scan(DIR_TO) + @line.scan(DIR) # + @line.scan(ENTER_DIR)
+    if dirs.size > 0
+      dirs.each { |d, room|
+	next if room == 'nil'
+	dir = DIRECTIONS[d]
+	@room.exits[dir] = room
+      }
+    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
+	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?(TADSRoom)
+      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     = TADSReader::unquote(desc)
+      room.darkness = !to.light
+      @tags[to.tag] = room
+      return [room, Connection::FREE]
+    elsif elem.kind_of?(TADSDoor)
+      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} TAG:#{r.tag} 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?(TADSObject)
+# 	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?(TADSObject)
+#       end
+
+      if to.kind_of?(TADSRoom) or to.kind_of?(TADSDoor)
+	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
+	p "GO: #{go} choose_dir"
+	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.exits.rindex(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 TADS properties window, to allow user to change
+  # settings
+  #
+  def properties
+    decor = DECOR_TITLE|DECOR_BORDER
+
+    dlg = FXDialogBox.new( @map.window.parent, "TADS 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 t3make(.exe) in path.
+    paths = ENV['PATH'].split(SEP)
+    paths.each { |p|
+      next if not File.directory?(p)
+      Dir.foreach(p) { |x|
+ 	if x =~ /^t3make(.exe)?$/i
+	  @include_dirs << p
+	  @include_dirs << p + "/include"
+	  @include_dirs << p + "/lib"
+	  @include_dirs << p + "/contrib"
+	  break
+	end
+      }
+    }
+  end
+
+  def initialize(file, map = Map.new('TADS 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(/\.t$/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"
+  TADSReader.new(ARGV[0])
+end