ifmapper 0.9.6 → 0.9.7

data/lib/IFMapper/IFMWriter.rb

@@ -167,7 +167,13 @@ class IFMWriter
       @f.puts
       @f.puts '#' * 79
       @f.puts
-      @f.puts "map \"#{section.name}\";" if section.name != ''
+      if section.name.to_s == ''
+	if @map.sections.size > 1
+	  @f.puts "map \"Section #{idx+1}\";"
+	end
+      else
+	@f.puts "map \"#{section.name}\";"
+      end
       @map.section = idx
       @link = nil
       section.rooms.each { |r|
@@ -192,10 +198,12 @@ class IFMWriter
 # (C) 2005 - Gonzalo Garramuno
 #
 
-title "#{@map.name}";
-
 HEADER
 
+    if @map.name.to_s != ''
+      puts "title \"#{@map.name}\";\n"
+    end
+
   end
 
 

data/lib/IFMapper/InformReader.rb

@@ -1,85 +1,129 @@
 
-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
+require "IFMapper/MapReader"
+
+
+# Take a quoted Inform string and return a valid ASCII one, replacing
+# Inform's special characters.
+module InformUnquote
+  TABLES = { 
+    ":a" => "\204",
+    ":e" => "\211",
+    ":i" => "\213",
+    ":o" => "\224",
+    ":u" => "\201",
+    ":y" => "\230",
+
+    ":A" => "\216",
+    ":E" => "\323",
+    ":I" => "\330",
+    ":O" => "\231",
+    ":U" => "\232",
+
+    "'a" => "\240",
+    "'e" => "\202",
+    "'i" => "\241",
+    "'o" => "\242",
+    "'u" => "\243",
+    "'y" => "\354",
+
+    "'A" => "\265",
+    "'E" => "\220",
+    "'I" => "\326",
+    "'O" => "\340",
+    "'U" => "\351",
+    "'Y" => "\355",
+
+    "^a" => "\203",
+    "^e" => "\210",
+    "^i" => "\214",
+    "^o" => "\223",
+    "^u" => "\226",
+
+    "^A" => "\266",
+    "^E" => "\322",
+    "^I" => "\327",
+    "^O" => "\342",
+    "^U" => "\352",
+
+    "`a" => "\205",
+    "`e" => "\212",
+    "`i" => "\215",
+    "`o" => "\225",
+    "`u" => "\227",
+
+    "`A" => "\267",
+    "`E" => "\324",
+    "`I" => "\336",
+    "`O" => "\343",
+    "`U" => "\353",
+
+    ",c" => "\207",
+    ",C" => "\200",
+
+    "~a" => "\306",
+    "~A" => "\307",
+    "~o" => "\344",
+    "~o" => "\345",
+
+
+    "~n" => "\244",
+    "~N" => "\245",
+
+    "!!"   => "\255",
+    '\?\?' => "\250",
+
+    ">>" => ">>",
+    "<<" => "<<",
+
+    # Missing 
+    "LL" => "",  # British pound
+
+    # greek letters
+    "ss" => "",  # beta
+
+    "et" => "",  # 
+    "Et" => "",  # 
+    "th" => "",  # thorn
+    "Th" => "",  # thorn
+
+    '\\o' => "",  # 
+    '\\O' => "",  # 
+
+    "oa" => "",  # o over a
+    "oA" => "",  # o over A
+    "ae" => "",
+    "AE" => "",
+    "oe" => "",
+    "OE" => "",
+  }
 
-  # Take a quoted Inform string and return a valid ASCII one, replacing
-  # Inform's special characters.
-  def self.unquote(text)
+  def unquote(text)
     return '' unless text
+    # deal with quotes
     text.gsub!(/\~/, '"')
+    # and newlines
     text.gsub!(/\^/, "\n")
+
+    # deal with accents and intl. chars
+    TABLES.each { |k, v|
+      text.gsub! /@#{k}/, v
+    }
+
+    # deal with zscii chars as numbers
     while text =~ /(@@(\d+))/
       text.sub!($1, $2.to_i.chr)
     end
     return text
   end
+end
 
-  # Temporary classes used to store inform room information
-  class InformObject
-    attr_reader   :name
-    attr_accessor :tag, :location, :enterable
-
-    def name=(x)
-      @name = InformReader::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::unquote(x)
-    end
-    def num_exits
-      return @exits.nitems
-    end
-    def method_missing(*x)
-    end
-    def initialize
-      @desc     = ''
-      @exits    = Array.new(12, nil)
-    end
-  end
+#
+# Class that allows creating a map from an Inform source file.
+#
+class InformReader < MapReader
 
+  STORY = /Constant\s+Story\s+\"([^"]+)\"/i
 
   DIRECTIONS = { 
     'n_to' => 0,
@@ -111,17 +155,28 @@ class InformReader
 
   attr_reader :map
 
-  @@debug = nil
-  def debug(*x)
-    return unless @@debug
-    $stdout.puts x
-    $stdout.flush
+
+  include InformUnquote
+
+  class InformRoom < MapRoom
+    include InformUnquote
+  end
+
+  class InformObject < MapObject
+    include InformUnquote
+  end
+
+
+  def new_room
+    super(InformRoom)
+  end
+
+  def new_obj(loc = nil)
+    super(loc, InformObject)
   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.
+  # Main parsing loop.  
   #
   def parse(file)
     # We start map at 0, 0
@@ -158,11 +213,12 @@ class InformReader
       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
+      rescue ParseError, MapError => e
+	message = "#{e}.\nat #{file.path}, line #{line_number}:\n>>>> #{full_line};\n"
+	raise message
+      rescue => e
+	message = "#{e}\n#{e.backtrace}" 
+	raise message
       end
     end
     debug "...End Parse..."
@@ -170,7 +226,7 @@ class InformReader
 
 
   CLASS       = /^class\s+(\w+)/i
-  DOOR        = /(?:^|\s+)door_to(?:\s+([^,;]*)|$)/i
+  DOOR        = /(?:^|\s+)door_to(?:\s+([^,;\[]*)|$)/i
   INCLUDE     = /^#?include\s+"([^"]+)"/i
   PLAYER_TO   = /\bplayerto\((\w+)/i
   DESCRIPTION = /(?:^|\s+)description(?:\s*$|\s+"([^"]+)?("?))/i
@@ -182,28 +238,6 @@ class InformReader
   ]
 
 
-  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)
@@ -221,14 +255,20 @@ class InformReader
   # Parse a line of file
   #
   def parse_line
+    if @line =~ STORY
+      @map.name = $1
+      return
+    end
+
     if @line =~ INCLUDE
       name = $1
       unless STD_LIB.include?(name)
 	file = find_file(name)
+	debug "include #{file}"
 	if file
 	  File.open(file, 'r') { |f| parse(f) }
 	else
-	  raise ParseError, "Include file #{name} not found"
+	  raise ParseError, "Include file '#{name}' not found"
 	end
       end
     end
@@ -273,17 +313,15 @@ EOF
 
       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
+	new_door
+      elsif @tag and (loc or c[:scenery] or c[:static])
+	new_obj(loc)
+	if c[:scenery] or c[:static]
+	  @obj.scenery = true 
+	end
       else
 	@obj = @room = nil
-	new_room if @tag and @name and c.has_key?(:light) 
+	new_room if @tag and @name and c.has_key?(:light)
       end
       @before = false
       @go     = false
@@ -306,16 +344,27 @@ EOF
 
     if @line =~ FUNCTION
       @functions << $1
+    elsif @tag and @line =~ DOOR
+      old_locations = []
+      if @obj
+	old_locations = @obj.location
+	@objects.delete(@obj) if @obj.tag == @tag
+	@tags[@tag] = nil
+      end
+      new_door
+      @obj.location  = $1.split(' ')
+      @obj.location += old_locations if old_locations.size > 0
+    else
+      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      
     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
@@ -330,25 +379,20 @@ EOF
       end
     end
 
-    if @obj.kind_of?(InformObject) and @before
+    if @obj.kind_of?(MapObject) and @before
       if @line =~ PLAYER_TO
 	@obj.enterable << $1
+	@obj.scenery = nil
       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
+      char  = props.include?('male') or props.include?('female')
+      if @obj and char
+	@obj.scenery = false
+      end
       props.each { |p|
 	if not @tag
 	  if p[0,1] == '~'
@@ -357,11 +401,13 @@ EOF
 	    @classes[@clas][p.to_sym] = true
 	  end
 	else
-	  if p =~ /locked/ and @doors.size > 0
+	  if p == 'locked' and @doors.size > 0
 	    @doors[-1].locked = true
 	  end
-	  if p =~ /(static|scenery)/ and @obj
-	    @objects.delete(@obj)
+	  if not char
+	    if p =~ /(?:static|scenery)/ and @obj
+	      @objects.delete(@obj)
+	    end
 	  end
 	  if p =~ /(\~)?light/
 	    new_room if not @room
@@ -371,7 +417,10 @@ EOF
       }
     end
 
-    if @line =~ /\bfound_in\s+(.*)[,;]?/
+    if @line =~ /\bfound_in\s+([^;,\[]*)/
+      if @tag and not @obj
+	new_obj(loc)
+      end
       if @obj
 	locs = $1.split
 	@obj.location = locs
@@ -381,371 +430,6 @@ EOF
   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(to, x, y, dx = 1, dy = 0)
-    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::unquote(desc)
-    room.darkness = !to.light
-    @tags[to.tag] = room
-    return room
-  end
-
-  def get_exit(from, to, x, y, dx = 1, dy = 0 )
-    elem = @tags[to.tag]
-    if elem.kind_of?(InformRoom)
-      room = create_room(to, x, y, dx, dy)
-      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 = create_room( o, x, y, dx, dy )
-	    return [ res, 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 = create_room( o, x, y, dx, dy )
-	  return [ res, 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 = 2, dy = 0)
-    return @tags[r.tag] if @tags[r.tag].kind_of?(Room)
-    from, = make_room(r, x, y, dx, dy)
-    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 = get_exit(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 from
-  end
-
-  #
-  # Create all the stuff we found
-  #
-  def create
-    @rooms = @rooms.sort_by { |r| r.num_exits }
-    @rooms.reverse!
-
-    @rooms.each { |r| 
-      min, max = @map.sections[@map.section].min_max_rooms
-      create_room(r, max[0] + 2, 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)
@@ -757,42 +441,19 @@ EOF
 	  @include_dirs << p + "/Base"
 	  @include_dirs << p + "/Contrib"
 	  @include_dirs << p + "/../Contrib"
+	  @include_dirs << p + "/../Lib/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}"
+    super
 
     if @map.kind_of?(FXMap)
       @map.filename   = file.sub(/\.inf$/i, '.map')