ifmapper 0.5

data/HISTORY.txt

@@ -0,0 +1,2 @@
+
+v0.5 - First public release on Rubyforge.

data/IFMapper.gemspec

@@ -0,0 +1,21 @@
+require "rubygems"
+
+spec = Gem::Specification.new do |spec|
+	spec.name = "ifmapper"
+	spec.version = '0.5'
+	spec.author = "Gonzalo Garramuno" 
+	spec.email = 'GGarramuno@aol.com or ggarram@advance.dsl.com.ar'
+	spec.homepage = 'http://www.rubyforge.org/projects/ifmapper/'
+	spec.summary = 'Interactive Fiction Mapping Tool.'
+	spec.require_path = "lib"
+	spec.files = ['IFMapper.rb'] + Dir.glob("lib/IFMapper/*.rb") + Dir.glob("maps/*.ifm") + Dir.glob("icons/*")
+	spec.description = <<-EOF
+	Interactive Fiction Mapping Tool.
+EOF
+	spec.add_dependency("fxruby", ">= 1.2.6")
+	spec.add_dependency("pdf-writer", ">= 1.1.1")
+	spec.extra_rdoc_files = ["HISTORY.txt", "IFMapper.gemspec"]
+	spec.has_rdoc = true
+	spec.rubyforge_project = 'ifmapper'
+	spec.required_ruby_version = '>= 1.6.8'
+end

data/IFMapper.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+# Add current path, so modules are found locally
+$LOAD_PATH << './lib'
+require 'IFMapper/FXMapperWindow'
+
+if __FILE__ == $0
+  # Make application
+  application = FXApp.new("IFMapper", "gga")
+
+  # Make window
+  m = FXMapperWindow.new(application)
+
+  # Create the application windows
+  application.create
+
+  # Run the application
+  begin
+    application.run
+  rescue => e
+    m.autosave
+    $stderr.puts e
+    $stderr.flush
+    raise e
+  end
+end
+

data/lib/IFMapper/Connection.rb

@@ -0,0 +1,63 @@
+
+#
+# Class used to represent a connection between one
+# room and another
+#
+class Connection
+  attr_accessor :type
+  attr_accessor :dir
+  attr_accessor :roomA,     :roomB
+  attr_accessor :exitAtext, :exitBtext
+
+  # Type constants
+  FREE        = 0
+  LOCKED_DOOR = 1
+  SPECIAL     = 2
+
+  # Direction constants
+  BOTH = 0
+  AtoB = 1
+  BtoA = 2
+
+  # Text near connection (to indicate other dir)
+  EXIT_TEXT = [
+    '',
+    'U',
+    'D',
+    'I',
+    'O'
+  ]
+
+  def initialize( roomA, roomB, dir = BOTH, type = FREE )
+    @roomA     = roomA
+    @roomB     = roomB
+    @dir       = dir
+    @type      = type
+    @exitAtext = 0
+    @exitBtext = 0
+  end
+
+  def to_s
+    dirA = dirB = ''
+    a = @roomA? @roomA.name : 'nil'
+    b = @roomB? @roomB.name : 'nil'
+    if exitAtext > 0
+      dirA = EXIT_TEXT[exitBtext]
+    else
+      if @roomA
+	idx  = @roomA.exits.index(self)
+	dirA = Room::DIRECTIONS[idx] if idx
+      end
+    end
+    if exitBtext > 0
+      dirB = EXIT_TEXT[exitBtext]
+    else
+      if @roomB
+	idx  = @roomB.exits.rindex(self)
+	dirB = Room::DIRECTIONS[idx] if idx
+      end
+    end
+    "#{a} #{dirA}<->#{b} #{dirB}"
+  end
+end
+

data/lib/IFMapper/FXAboutDialogBox.rb

@@ -0,0 +1,32 @@
+
+
+class FXAboutDialogBox < FXDialogBox
+
+  def initialize(parent, title, text)
+    decor = DECOR_TITLE|DECOR_BORDER|DECOR_CLOSE
+
+    super( parent, title, decor, 40, 40, 0, 0 )
+    mainFrame = FXVerticalFrame.new(self,
+				    FRAME_SUNKEN|FRAME_THICK|
+				    LAYOUT_FILL_X|LAYOUT_FILL_Y)
+
+    frame = FXHorizontalFrame.new(mainFrame, LAYOUT_SIDE_TOP|LAYOUT_FILL_X)
+
+    FXLabel.new(frame, text, nil, 0, LAYOUT_FILL_ROW)
+
+#     c = FXText.new(frame, nil, 0, LAYOUT_FILL_ROW)
+#     c.visibleRows    = 10
+#     c.visibleColumns = 80
+#     c.editable = false
+#     c.text = text
+
+    buttons = FXHorizontalFrame.new(mainFrame, 
+				    LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|
+				    PACK_UNIFORM_WIDTH)
+    # Accept
+    FXButton.new(buttons, "&Super!", nil, self, FXDialogBox::ID_ACCEPT,
+		 FRAME_RAISED|LAYOUT_FILL_X|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y)
+
+    create
+  end
+end

data/lib/IFMapper/FXConnection.rb

@@ -0,0 +1,283 @@
+
+require 'IFMapper/FXSpline'
+require 'IFMapper/Connection'
+require 'IFMapper/FXConnectionDialogBox'
+
+######################################################
+#
+#               WW
+#    +---------------------+
+#    |         W           |
+#    |   +-------------+   |
+# HH |   |             |WS2|
+#    | H |             |---|
+#    |   +-------------+   |
+#    |       |HS2          |
+#    +---------------------+
+#
+#####################################################
+
+W  = 120
+H  = 75
+WS = 40
+HS = 40
+WW = W+WS
+HH = H+HS
+
+WS_2 = WS / 2
+HS_2 = HS / 2
+
+WIDX = 24
+HIDX = 18
+
+
+class FXConnection < Connection
+  attr_accessor :selected
+  attr_accessor :failed
+  attr_accessor :pts, :gpts
+
+  @@win = nil
+
+  def initialize( roomA, roomB, dir = Connection::BOTH, 
+		 type = Connection::FREE )
+    super( roomA, roomB, dir, type )
+    @selected  = @failed = false
+    @pts = @gpts = []
+  end
+
+  def marshal_load(vars)
+    @selected, @type, @dir, @roomA, @roomB,
+      @exitAtext, @exitBtext = vars
+    @pts = @gpts = []
+  end
+
+  def marshal_dump
+    [ @selected, @type, @dir, @roomA, @roomB, @exitAtext, @exitBtext ]
+  end
+
+  def selected=(value)
+    if value and @@win
+      @@win.copy_from(self)
+    end
+    @selected = value
+  end
+
+  def toggle_direction
+    # If a self-loop, we cannot change dir
+    if @roomA == @roomB
+      return if @roomA.exits.index(self) ==  @roomA.exits.rindex(self)
+    end
+
+    @dir += 1
+    if @dir > BtoA
+      @dir = BOTH
+    end
+
+    if @@win
+      @@win.copy_from(self)
+    end
+  end
+
+  #
+  # Is this a complex path.  Check if connection is
+  # contiguous
+  #
+  def complex?()
+    return false if not @roomB
+    return true if @roomB == @roomA
+    return true unless @roomA.next_to?(@roomB)
+
+    # Even if rooms are next to each other, we need to
+    # verify that following the exits does indeed take us to next room.
+    exitA = @roomA.exits.index(self)
+    dir   = Room::DIR_TO_VECTOR[exitA]
+
+    if @roomA.x + dir[0] == @roomB.x and
+	@roomA.y + dir[1] == @roomB.y
+      exitB = @roomB.exits.rindex(self)
+      dir   = Room::DIR_TO_VECTOR[exitB]
+      if @roomB.x + dir[0] == @roomA.x and
+	  @roomB.y + dir[1] == @roomA.y
+	return false
+      else
+	return true
+      end
+    else 
+      return true
+    end
+  end
+
+  def draw_complex_as_lines(dc, zoom)
+    p = []
+    @pts.each { |pt|
+      p << FXPoint.new( (pt[0] * zoom).to_i, (pt[1] * zoom).to_i )
+    }
+    dc.drawLines( p )
+    return p
+  end
+
+  def draw_complex_as_bspline(dc, zoom)
+    p = []
+    p << [ @pts[0][0] * zoom, @pts[0][1] * zoom ]
+    p << p[0]
+    p << p[0]
+    @pts.each { |pt|
+      p << [ pt[0] * zoom, pt[1] * zoom ]
+    }
+    p << p[-1]
+    p << p[-1]
+    p << p[-1]
+    return dc.drawBSpline( p )
+  end
+
+  def draw_complex(dc, zoom, opt)
+    if opt['Paths as Curves']
+      p = draw_complex_as_bspline(dc, zoom)
+    else
+      p = draw_complex_as_lines(dc, zoom)
+    end
+
+    x1, y1 = [p[0].x, p[0].y]
+    x2, y2 = [p[-1].x, p[-1].y]
+    draw_arrow(dc, zoom, x1, y1, x2, y2)
+  end
+
+  def draw_simple(dc, zoom)
+    dir    = @roomA.exits.index(self)
+    x1, y1 = @roomA.corner(self, zoom, dir)
+    if @roomB
+      x2, y2 = @roomB.corner(self, zoom)
+      dc.drawLine( x1, y1, x2, y2 )
+      draw_arrow(dc, zoom, x1, y1, x2, y2)
+      if @type == LOCKED_DOOR
+	v = [ (x2-x1)*0.25, (y2-y1)*0.25 ]
+	m = [ (x2+x1)/2, (y2+y1)/2 ]
+	x1, y1 = [m[0] + v[1], m[1] - v[0]]
+	x2, y2 = [m[0] - v[1], m[1] + v[0]]
+	dc.drawLine(x1, y1, x2, y2)
+      end
+    else
+      v = FXRoom::DIR_TO_VECTOR[dir]
+      x2, y2 = [ @roomA.x + v[0] * 0.5, @roomA.y + v[1] * 0.5 ]
+      x2 *= WW * zoom
+      y2 *= HH * zoom
+      x2 += WW / 2 * zoom
+      y2 += HH / 2 * zoom
+      dc.drawLine( x1, y1, x2, y2 )
+    end
+  end
+
+  RAD_45 = 45 * Math::PI / 180
+  SIN_45 = Math.sin(RAD_45)
+  COS_45 = Math.cos(RAD_45)
+
+  def _arrow_info( x1, y1, x2, y2, zoom = 1.0 )
+    pt1  = []
+    dir = 0
+    if    @dir == AtoB 
+      dir = @roomB.exits.rindex(self)
+      pt1 = [ x2, y2 ]
+    else
+      dir = @roomA.exits.index(self)
+      pt1 = [ x1, y1 ]
+    end
+    x, y      = Room::DIR_TO_VECTOR[dir]
+    arrow_len = 20.0 / Math.sqrt(x * x + y * y)
+    x *= arrow_len *  zoom
+    y *= arrow_len * -zoom
+
+    d = [
+      x * COS_45 + y * SIN_45,
+      x * SIN_45 - y * COS_45
+    ]
+    return pt1, d
+  end
+
+
+  def draw_arrow( dc, zoom, x1, y1, x2, y2 )
+    return if @dir == BOTH
+    pt1, d = _arrow_info( x1, y1, x2, y2, zoom )
+
+    p = []
+    p << FXPoint.new( pt1[0].to_i, pt1[1].to_i )
+    pt2 = [ pt1[0] + d[0], pt1[1] + d[1] ]
+    p << FXPoint.new( pt2[0].to_i, pt2[1].to_i )
+    pt2 = [ pt1[0] + d[1], pt1[1] - d[0] ]
+    p << FXPoint.new( pt2[0].to_i, pt2[1].to_i )
+    
+    dc.fillPolygon(p)
+  end
+
+  def draw_text(dc, zoom, x, y, dir, text, arrow)
+    if dir == 7 or dir < 6 and dir != 1
+      if arrow and (dir == 0 or dir == 4)
+	x += 10 * zoom
+      end
+      x += 5 * zoom
+    elsif dir == 6 or dir == 1
+      x -= 15 * zoom
+    end
+    
+    if dir > 5 or dir < 4
+      if arrow and (dir == 6 or dir == 2)
+	y -= 10 * zoom
+      end
+      y -= 5 * zoom
+    elsif dir == 4 or dir == 5
+      y += 15 * zoom
+    end
+    
+    dc.drawText(x, y, text)
+  end
+
+  def draw_exit_text(dc, zoom)
+    if @exitAtext != 0
+      dir  = @roomA.exits.index(self)
+      x, y = @roomA.corner(self, zoom, dir)
+      draw_text( dc, zoom, x, y, dir, 
+		EXIT_TEXT[@exitAtext], @dir == BtoA)
+    end
+    if @exitBtext != 0
+      dir  = @roomB.exits.rindex(self)
+      x, y = @roomB.corner(self, zoom, dir)
+      draw_text( dc, zoom, x, y, dir, 
+		EXIT_TEXT[@exitBtext], @dir == AtoB)
+    end
+  end
+
+  def draw(dc, zoom, opt)
+    if @selected
+      dc.foreground = 'yellow'
+    elsif @failed
+      dc.foreground = 'red'
+    else
+      dc.foreground = opt['Arrow Color']
+    end
+
+    draw_exit_text(dc, zoom)
+    if @type == SPECIAL
+      dc.lineStyle = LINE_ONOFF_DASH
+    else
+      dc.lineStyle = LINE_SOLID
+    end
+    if pts.size > 0
+      draw_complex(dc, zoom, opt)
+    else
+      draw_simple(dc, zoom)
+    end
+  end
+
+
+  def properties(map, event = nil)
+    if not @@win
+      @@win = FXConnectionDialogBox.new(map, self, event)
+    else
+      @@win.map = map
+    end
+    @@win.copy_from(self)
+    @@win.show
+    return
+  end
+
+end
+