straightedge 0.1.0 → 0.1.1

data/lib/straightedge/figures/hexagon.rb

@@ -0,0 +1,33 @@
+module Straightedge::Figures
+  class Hexagon < Figure
+    attr_accessor :scale
+
+    def initialize(location: Straightedge::ORIGIN, color: :white, scale: 1.0)
+      super(location: location, color: color)
+      @scale      = scale
+      @marks      = corners
+    end
+
+    # lots of magic here...
+    def left_triangle
+      corners[0..2]
+    end
+
+    def right_triangle
+      corners[3..5]
+    end
+
+    def center_quad
+      [corners[0], corners[2], corners[3], corners[5]]
+    end
+
+    def corners
+      Array.new(6) do |i|
+	angle = 2 * Math::PI / 6 * (i+2)
+	x_i = x + scale * Math.cos(angle)
+	y_i = y + scale * Math.sin(angle)
+	[x_i, y_i]
+      end
+    end
+  end
+end

data/lib/straightedge/figures/label.rb

@@ -0,0 +1,13 @@
+module Straightedge
+  module Figures
+    # technically a label isn't even a figure, just a mark with an associated string
+    class Label < Mark
+      attr_reader :text
+      
+      def says(text)
+	@text = text
+	self
+      end
+    end
+  end
+end

data/lib/straightedge/figures/line.rb

@@ -0,0 +1,25 @@
+module Straightedge
+  module Figures
+    class Line < Figure
+      def alpha
+	@marks[0]
+      end
+
+      def beta
+	@marks[1]
+      end
+
+      def dx
+	alpha.x - beta.x
+      end
+
+      def dy
+	alpha.y - beta.y
+      end
+
+      def length
+	Math.sqrt(dx*dx + dy*dy)
+      end
+    end
+  end
+end

data/lib/straightedge/figures/mark.rb

@@ -0,0 +1,23 @@
+module Straightedge
+  module Figures
+    #
+    # a mark is an optionally-colored position
+    #
+    class Mark
+      extend Forwardable
+      include Straightedge::Aspects::Colorable
+
+      attr_accessor :location
+
+      def initialize(*xy, color: :white)
+	@location = xy # [xy[0], xy[1]]
+	@color = color
+      end
+
+      def x; @location[0] end
+      def y; @location[1] end
+
+      def self.empty(*xy); new(*xy, color: :none) end
+    end
+  end
+end

data/lib/straightedge/figures/quadrilateral.rb

@@ -0,0 +1,20 @@
+module Straightedge
+  module Figures
+    class Quadrilateral < Figure
+      attr_reader :dimensions
+      def_delegator :dimensions, :x, :width
+      def_delegator :dimensions, :y, :height
+
+      def initialize(dimensions: [1,1], location: ORIGIN, color: :white)
+	super([], location: location, color: color)
+	@dimensions = dimensions
+	@marks      = corners
+      end
+
+      def corners(w=width, h=height)
+	@corners ||= [[x,y],[x,y+h],[x+w,y+h],[x+w,y]]
+	#Rose.simple.project(origin).map { |xy| [xy.x*w, xy.y*h] }
+      end
+    end
+  end
+end

data/lib/straightedge/motor/adapter.rb

@@ -0,0 +1,54 @@
+module Straightedge
+  class Adapter
+    include Straightedge::Figures
+    attr_accessor :agent
+    attr_reader   :plane
+    
+    def initialize(agent: Director.new, plane: nil)
+      @agent = agent
+      adapt(plane) if plane
+    end
+
+    def adapt(plane)
+      @plane = plane
+      @plane.adapter = self
+      @agent.prepare_stage([plane.width, plane.height])
+    end
+
+    def kickstart
+      @plane.display unless @plane.nil?
+    end
+
+    def render
+      scene = @agent.current_scene.is_a?(Hash) ? Scene.new(agent.current_scene) : agent.current_scene
+      scene.render(self)
+    end
+
+    # note the ordering is important, since e.g., grid < quad
+    def presenter_for(figure)
+      figures_and_presenters = Straightedge.config.presenter_classes 
+      matched_class = figures_and_presenters.keys.detect { |k| figure.class <= k }
+
+      klass = if matched_class
+		figures_and_presenters[matched_class]
+	      else
+		raise "no presenter class for #{figure}"
+	      end
+
+      new_presenter = klass.new
+      new_presenter.on(@plane) unless @plane.nil?
+      new_presenter
+    end
+
+    def step
+      @agent.orchestrate
+    end
+
+    def click(x,y)
+      @agent.handle(:click, x, y)
+    end
+  end
+
+  config.presenter_classes = {}
+  config.adapter_class = Adapter
+end

data/lib/straightedge/motor/engine.rb

@@ -0,0 +1,16 @@
+module Straightedge
+  class Engine
+    attr_reader :adapter, :surface, :agent
+    def initialize(surface_geometry=Straightedge.config.geometry)
+      @agent   = Straightedge.new_agent
+      @surface = Straightedge.new_surface(surface_geometry)
+      @adapter = Straightedge.new_adapter(agent: @agent, plane: @surface)
+    end
+
+    def boot
+      @adapter.kickstart
+    end
+  end
+
+  config.engine_class = Engine
+end

data/lib/straightedge/origin.rb

@@ -0,0 +1,3 @@
+module Straightedge
+  ORIGIN = [0, 0]
+end

data/lib/straightedge/presenter.rb

@@ -0,0 +1,29 @@
+module Straightedge
+  # TODO something with this
+  class Presenter
+    extend Forwardable
+    #def_delegators :location, :x, :y
+
+    def on(surface)
+      @surface = surface
+      self
+    end
+
+    #def at(p)
+    #  @location = p
+    #  self 
+    #end
+
+    def display(figure)
+      raise 'implement in subclass'
+    end
+
+    #def location
+    #  @location ||= [0,0]
+    #end
+
+    #def color(figure)
+    #  @color ||= 0xEFEFEFEF
+    #end
+  end
+end

data/lib/straightedge/scene.rb

@@ -0,0 +1,20 @@
+module Straightedge
+  # some boilerplate to bootstrap a rendering engine
+  class Scene
+    attr_reader :locations_and_figures
+
+    def initialize(locations_and_figures={})
+      @locations_and_figures = locations_and_figures
+    end
+
+    def render(adapter=nil)
+      return false unless adapter
+      @locations_and_figures.each do |location,figure|
+	figure = Figures::Label.new.says(figure) if figure.is_a?(String)
+	figure.location = location
+	presenter = adapter.presenter_for(figure)
+	presenter.display(figure)
+      end
+    end
+  end
+end

data/lib/straightedge/surface.rb

@@ -0,0 +1,21 @@
+module Straightedge
+  module Surface
+    attr_accessor :adapter
+    attr_reader :width, :height
+
+    def display
+      warn 'implement in subclass'
+    end
+  end
+
+  class AbstractSurface
+    include Surface
+
+    def initialize(geometry, adapter: adapter)
+      @width, @height = *geometry
+      @adapter = adapter
+    end
+  end
+
+  config.surface_class = AbstractSurface
+end

data/lib/straightedge/toolkit/compass.rb

@@ -0,0 +1,19 @@
+module Straightedge
+  module Toolkit
+    class Compass
+      extend Forwardable
+      attr_accessor :rose
+      def_delegator :rose, :project
+
+      def initialize(rose=Rose.extended)
+	@rose = rose
+      end
+
+      class << self
+	def default
+	  @default_compass ||= new
+	end
+      end
+    end
+  end
+end

data/lib/straightedge/toolkit/rose.rb

@@ -0,0 +1,60 @@
+module Straightedge
+  module Toolkit
+    class Rose
+      attr_reader :directions
+
+      def initialize(directions:{})
+	@directions = directions
+      end
+
+      def project(point)
+	@directions.values.collect do |delta|
+	  Ruler.translate(point, delta)
+	end
+      end
+
+      class << self
+	def simple
+	  return @simple_rose unless @simple_rose.nil?
+	  @simple_rose = new directions: {
+	    :north => [0, -1],
+	    :south => [0,  1],
+	    :east  => [1,  0],
+	    :west  => [-1, 0]
+	  } 
+	end
+
+	# for hex navigation (nb coords are in cube-space)
+	def hexagonal
+	  return @hex_rose unless @hex_rose.nil?
+	  @hex_rose = new directions: {
+	    :north     => [1, -1, 0],
+	    :northeast => [0, -1, 1],
+	    :northwest => [1, 0, -1],
+	    :south     => [-1, 1, 0],
+	    :southeast => [-1, 0, 1],
+	    :southwest => [0, 1, -1]
+	  }
+	end
+
+	def extended
+	  return @extended_rose unless @extended_rose.nil?
+	  simple_rose_axes = [[:east,:west],[:north, :south]]
+	  extended_directions = permute(simple, simple_rose_axes)
+	  all_directions = simple.directions.merge(extended_directions)
+	  @extended_rose = new directions: all_directions
+	end
+
+	def permute(rose, axes)
+	  combinations = axes.x.map do |x|
+	    axes.y.map do |y|
+	      ["#{y}#{x}".to_sym, Ruler.translate(rose.directions[x], rose.directions[y])]
+	    end
+	  end
+
+	  Hash[combinations.flatten(1)]
+	end
+      end
+    end
+  end
+end

data/lib/straightedge/toolkit/ruler.rb

@@ -0,0 +1,23 @@
+module Straightedge
+  module Toolkit
+    class Ruler
+      attr_reader :unit
+
+      def initialize(unit: 1)
+	@unit = unit
+      end
+
+      class << self
+	def default; @default ||= new end
+
+	def translate(xy, dxy)
+	  xy.zip(dxy).map { |x,y| x+y }
+	end
+
+	def distance(alpha,beta)
+	  Straightedge::Figures::Line.new([alpha,beta]).length
+	end
+      end
+    end
+  end
+end

data/lib/straightedge/tools.rb

@@ -0,0 +1,3 @@
+require 'straightedge/toolkit/compass'
+require 'straightedge/toolkit/rose'
+require 'straightedge/toolkit/ruler'

data/lib/straightedge/version.rb

@@ -1,4 +1,4 @@
 module Straightedge
   # straightedge version
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/spec/spec_helper.rb

@@ -1,5 +1,8 @@
 require 'rspec'
+require 'rspec/its'
 require 'pry'
-require 'straightedge/version'
+require 'straightedge'
 
 include Straightedge
+include Straightedge::Figures
+include Straightedge::Toolkit

data/spec/straightedge/adapter_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+class GridPresenter; end
+Straightedge.config.presenter_classes = { Grid => GridPresenter }
+
+describe Adapter do
+  let(:director) { Director.new }
+  subject { Adapter.new(agent: director) }
+
+  it 'should find presenters' do
+    expect(subject.presenter_for(Grid.new)).to be_a(GridPresenter)
+    #expect(subject.presenter_for(Space.new)).to be_a(GridPresenter)
+  end
+end

data/spec/straightedge/director_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+describe Director do
+  subject { Director.new }
+  let(:adapter) { Adapter.new(agent: subject) }
+
+  it 'should respond to adapter events' do
+    expect(subject).to receive(:handle).with(:click, 1,2)
+    adapter.click(1,2)
+  end
+end

data/spec/straightedge/extend/array_spec.rb

@@ -1,9 +1,4 @@
 require 'spec_helper'
-require 'straightedge/mark'
-require 'straightedge/figure'
-require 'straightedge/compass'
-require 'straightedge/rose'
-require 'straightedge/extend/array'
 require 'pry'
 
 describe Array do
@@ -34,7 +29,7 @@ describe Array do
       end
 
       let(:expected_adjacent) do
-	[[1, 1], [1, 3], [2, 2], [0, 2], [2, 1], [2, 3], [0, 1], [0, 3], [3, 1], [3, 3], [4, 2], [4, 1], [4, 3]]
+	[[2, 2], [2, 3], [2, 1], [1, 1], [3, 1], [1, 3], [3, 3], [4, 2], [0, 2], [0, 1], [0, 3], [4, 1], [4, 3]]
       end
       it 'should have adjacent coordinates' do
 	expect(subject.adjacent).to eql(expected_adjacent)