lacci 0.2.1 → 0.2.2

data/examples/legacy/not_checked/expert/colours.rb

@@ -1,105 +0,0 @@
-# https://en.wikipedia.org/wiki/Farnsworth-Munsell_100_hue_test
-
-SQUARES = 22
-SQUARE_SIZE = 50
-SQUARE_PADDING = 2
-
-TITLE = "Farnsworth-Munsell 100 Hue Color Vision Test [COMPLETED %d%%]"
-
-HUES = [
-   [[172, 118, 114], [143, 140, 74]],
-   [[143, 140, 74], [84, 151, 137]],
-   [[84, 151, 137], [128, 136, 165]],
-   [[128, 136, 165], [173, 119, 118]]
-]
-
-def generate_rgb(rgb_start, rgb_end, segments = 2)
-   rstep, gstep, bstep = 3.times.collect { |n|
-      rgb_start[n].to_f.step(
-         by: ((rgb_end[n] - rgb_start[n]) / (segments - 1).to_f), 
-         to: rgb_end[n]
-      ).to_a
-   }
-   
-   segments.times.collect { |n| rgb(rstep[n].floor, gstep[n].floor, bstep[n].floor) }
-end
-
-Shoes.app(width: (SQUARE_SIZE + SQUARE_PADDING) * SQUARES + SQUARE_PADDING, height: (SQUARE_SIZE + SQUARE_PADDING) * HUES.size + SQUARE_PADDING, title: TITLE % 0, resizable: false) do
-   flow(top: SQUARE_PADDING, left: SQUARE_PADDING / 2, width: (SQUARE_SIZE + SQUARE_PADDING) * SQUARES)  do
-      @hues = HUES.collect { |rgb_start, rgb_end| generate_rgb(rgb_start, rgb_end, SQUARES) }
-      @hues.collect { |n| [n.first, n[1..-2].shuffle, n.last].flatten }.each_with_index { |list, index|
-         SQUARES.times { |n|
-               (@r ||= []) << rect(left: (SQUARE_SIZE + SQUARE_PADDING) * n, top: (SQUARE_SIZE + SQUARE_PADDING) * ((n + (index * SQUARES)) / SQUARES), width: SQUARE_SIZE, height: SQUARE_SIZE)
-               @r.last.fill = @r.last.stroke = list[n]
-         }
-      }
-   end
-   @top_rect = rect(width: SQUARE_SIZE, height: SQUARE_SIZE).hide
-   
-   motion do |left, top|
-      @top_rect.move(left - (@controller.width / 2), top - (@controller.height / 2)) unless @controller.nil?
-   end
-
-   @anim = animate(10) do |frame|
-      if 0 == frame % 5
-         set_window_title(TITLE % (@completed * 100 / @r.size)) unless @completed.nil?
-         if @highlight
-            @hues.flatten.each_with_index { |item, index|
-               @r[index].stroke = item.eql?(@r[index].fill) ? @r[index].fill : rgb(255, 0, 0)
-            }
-         else
-            @r.each { |n| n.stroke = n.fill }
-         end
-      end
-      if @success
-         5.times {
-            a, b = rand(@r.size), rand(@r.size)
-            @r[a].fill, @r[b].fill = @r[b].fill, @r[a].fill
-         }
-      end
-   end
-   
-   keypress do |k|
-      @highlight ^= true if k.eql?("h")
-   end
-   
-   start do
-      @highlight = false
-      @r.each_with_index { |n, skip|
-         next if 0 == skip % SQUARES or (SQUARES - 1) == (skip % SQUARES)
-         n.click do |btn, left, top|
-            if @success
-               set_window_title(TITLE % (@completed = 0))
-               @hues.collect { |n| [n.first, n[1..-2].shuffle, n.last].flatten }.flatten.each_with_index { |item, index|
-                  @r[index].fill = @r[index].stroke = item
-               }
-               @success = false
-               @top_rect.hide unless @top_rect.nil?
-               @controller = nil
-               next
-            end
-            
-            unless @controller.nil?
-               if n.top.eql?(@controller.top)
-                  n.fill, @controller.fill = @controller.fill, n.fill
-                  n.stroke, @controller.stroke = @controller.stroke, n.stroke
-                  
-                  @top_rect.hide
-                  @controller = nil
-               end
-            else
-               @controller = n
-               @top_rect.left, @top_rect.top = n.left, n.top
-               @top_rect.fill, @top_rect.stroke = n.fill, n.stroke
-               @top_rect.show
-            end
-            
-            @success = true
-            @completed = 0
-            @hues.flatten.each_with_index { |item, index|
-               item.eql?(@r[index].fill) ? @completed += 1 : @success = false
-            }
-         end
-      }
-   end
-end

data/examples/legacy/not_checked/expert/curve-animation.rb

@@ -1,31 +0,0 @@
-Shoes.app(:title => "Expert curve_to animation", :resizable => false) do
-      xy = [
-         [app.slot.width / 6, -app.slot.height],
-         [app.slot.width / 6, app.slot.height / 2],
-         [app.slot.width / 6, app.slot.height + 50]
-      ]
-      colors = [
-         rgb(49, 156, 0, 0.35),
-         rgb(255, 255, 255, 0.35),
-         rgb(222, 33, 16, 0.35)
-      ]
-      
-      @waves = stack :top => 0, :left => 0
-      animate(8) { |ani|
-         a = Math.sin(ani * 0.02) * 8
-         @waves.clear do
-            nofill
-            strokewidth app.slot.width / 3
-            6.times { |i|
-               colors.each_with_index { |color, n|
-                  shape do
-                     v = 4.times.collect { rand(0.1) * 100 > 50 ? +1 : -1 }
-                     move_to (dx = n * app.slot.width / 3) + xy[n][0] + (v[0] * i * a * 0.8), xy[0][1]
-                     stroke color
-                     curve_to dx + xy[0][0] + (v[1] * i * a), xy[0][1], dx + xy[1][0] + (v[2] * i * a * 2), xy[1][1], dx + xy[2][0] + (v[3] * i * a), xy[2][1]
-                  end
-               }
-            }
-         end
-      }
-end

data/examples/legacy/not_checked/expert/curve-control-point.rb

@@ -1,51 +0,0 @@
-# https://github.com/casparjones/First-Ruby-Steps/blob/master/shoes-samples/simple-curve.rb
-# http://www.cairographics.org/samples/curve_to/
-
-# curve_to with visible control points.
-# The ovals represent the control points.
-Shoes.app(title: "Expert curve_to control points", width: 500, height: 400) do
-   xy = [
-      [self.width / 8, self.height / 2], 
-      [self.width / 8 * 3, self.height / 4 * 3], 
-      [self.width / 8 * 4, self.height / 4], 
-      [self.width / 8 * 7, self.height / 2]
-   ]
-
-   para "click and drag control points..."
-   fill green(0.2)
-   move_to *xy[0]
-   
-   @controller = nil
-   xy.each { |n|
-      (@controllers ||= []) << oval(:left => n[0], :top => n[1], :radius => 10, :center => true)
-   }
-   @controllers.each { |n|
-      n.click do |btn, left, top|
-         n.style :fill => red
-         @controller = n
-      end
-      n.release do |btn, left, top|
-         n.style :fill => green(0.2)
-         @controller = nil
-      end
-   }
-   
-   motion do |left, top|
-      unless @controller.nil?
-         xy[@controllers.index(@controller)] = left, top
-         @controller.left, @controller.top = left, top
-      end
-   end
-   
-   @stack = stack :top => 0, :left => 0
-   
-   animate(10) do
-      @stack.clear do
-         fill red(0.2)   
-         shape do
-            move_to *xy[0]
-            curve_to *xy[1], *xy[2], *xy[3]
-         end
-      end
-   end
-end

data/examples/legacy/not_checked/expert/custom-list-box.rb

@@ -1,53 +0,0 @@
-require("observer")
-
-class Items
-  include Observable
-  
-  def initialize(array)
-    @array = array
-  end
-  
-  def method_missing(meth, *args, &block)
-    @array.send(meth, *args, &block)
-    changed
-    notify_observers(@array, meth, *args, &block)
-  end
-end
-
-class CustomListBox < Shoes::Widget
-  attr_accessor :items
-  
-  def initialize(options = {}, &block)
-    @lb = list_box options, &block
-    @items = Items.new(@lb.items)
-    @items.add_observer(self)
-  end
-  
-  def method_missing(meth, *args, &block)
-    if @lb.respond_to? meth
-      @lb.send(meth, *args, &block)
-    else
-      super
-    end
-  end
-  
-  def update(array, *call)
-    @lb.items = array
-  end
-end
-
-Shoes.app {
-  @p = para "Any selection?"
-  @l = custom_list_box :items => ["first", "second"], :choose => "first" do |n|
-    @p.replace "Selection is #{n.text}."
-  end
-  @e = edit_line
-
-  button "ok" do
-    @l.items << @e.text
-  end
-  
-  button "collect" do
-    @l.items.collect! { |n| n.reverse }
-  end
-}

data/examples/legacy/not_checked/expert/definr.rb

@@ -1,23 +0,0 @@
-Shoes.app :title => "Dictionary, powered by Definr", :width => 370, :height => 320 do
-  stack do
-    background red, :height => 60
-    flow :margin => 20 do
-      caption "Define: ", :stroke => white
-      @lookup = edit_line
-      button "Go" do
-        download "http://definr.com/definr/show/#{@lookup.text}" do |dl|
-          doc = dl.response.body.gsub(' ', ' ').
-              gsub(%r!(</a>|<br />|<a href.+?>)!, '').
-              gsub(%r!\(http://.+?\)!, '').strip
-          title, doc = doc.split(/\n+/, 2)
-          @deft.replace title
-          @defn.replace doc
-        end
-      end
-    end
-    stack :margin => 20 do
-      @deft = subtitle "", :margin => 10
-      @defn = para ""
-    end
-  end
-end

data/examples/legacy/not_checked/expert/funnies.rb

@@ -1,56 +0,0 @@
-# This example tries Nokogiri (used in Shoes 4)
-require 'nokogiri'
-
-class Comic
-  attr_reader :rss, :title
-
-  def initialize(body)
-    @rss = Nokogiri::XML(body)
-    @title = @rss.at("//channel/title").inner_text
-  end
-
-  def items
-    @rss.search("//channel/item")
-  end
-
-  def latest_image
-    @rss.search("//channel/item").first.inner_html.scan(/src="([^"]+\.\w+)"/).first
-  end
-end
-
-Shoes.app width: 800, height: 600 do
-  background "#555"
-
-  @title = "Web Funnies"
-  @feeds = [
-    "http://xkcd.com/rss.xml",
-    # No longer contains images
-    #"http://feedproxy.google.com/DilbertDailyStrip?format=xml",
-    # debug
-    #"http://www.smbc-comics.com/rss.php",
-    #"http://www.daybydaycartoon.com/index.xml",
-    #"http://www.questionablecontent.net/QCRSS.xml",
-    #"http://indexed.blogspot.com/feeds/posts/default?alt=rss"
-    ]
-
-  stack margin: 10 do
-    title strong(@title), align: "center", stroke: "#DFA", margin: 0
-    para "(loaded from RSS feeds)", align: "center", stroke: "#DFA",
-      margin: 0
-
-    @feeds.each do |feed|
-      download feed do |dl|
-        stack width: "100%", margin: 10, border: 1 do
-          # Fall back to Shoes 3 syntax if necessary
-          body = dl.respond_to?(:read) ? dl.read : dl.response.body
-          c = Comic.new body
-          stack margin_right: gutter do
-            background "#333", curve: 4
-            caption c.title, stroke: "#CD9", margin: 4
-          end
-          image c.latest_image.first, margin: 8
-        end
-      end
-    end
-  end
-end

data/examples/legacy/not_checked/expert/minesweeper.rb

@@ -1,267 +0,0 @@
-#
-# Shoes Minesweeper by que/varyform
-#
-LEVELS = { :beginner => [9, 9, 10], :intermediate => [16, 16, 40], :expert => [30, 16, 99] }
-
-class Field
-  CELL_SIZE = 20
-  COLORS = %w(#00A #0A0 #A00 #004 #040 #400 #000)
-  
-  class Cell
-    attr_accessor :flag
-    def initialize(aflag = false)
-      @flag = aflag
-    end
-  end
-  
-  class Bomb < Cell
-    attr_accessor :exploded
-    def initialize(exploded = false)
-      @exploded = exploded
-    end
-  end
-  
-  class OpenCell < Cell
-    attr_accessor :number
-    def initialize(bombs_around = 0)
-      @number = bombs_around
-    end
-  end
-  
-  class EmptyCell < Cell; end
-  
-  attr_reader :cell_size, :offset
-  
-  def initialize(app, level = :beginner)
-    @app = app
-    @field = []
-    @w, @h, @bombs = LEVELS[level][0], LEVELS[level][1], LEVELS[level][2]
-    @h.times { @field << Array.new(@w) { EmptyCell.new } }
-    @game_over = false
-    @width, @height, @cell_size = @w * CELL_SIZE, @h * CELL_SIZE, CELL_SIZE
-    @offset = [(@app.width - @width.to_i) / 2, (@app.height - @height.to_i) / 2]
-    plant_bombs
-    @start_time = Time.now
-  end
-  
-  def total_time
-    @latest_time = Time.now - @start_time unless game_over? || all_found?
-    @latest_time
-  end
-  
-  def click!(x, y)
-    return unless cell_exists?(x, y)
-    return if has_flag?(x, y)
-    return die!(x, y) if bomb?(x, y)
-    open(x, y)
-    discover(x, y) if bombs_around(x, y) == 0
-  end  
-
-  def flag!(x, y)
-    return unless cell_exists?(x, y)
-    self[x, y].flag = !self[x, y].flag unless self[x, y].is_a?(OpenCell)
-  end  
-  
-  def game_over?
-    @game_over 
-  end
-  
-  def render_cell(x, y, color = "#AAA", stroke = true)
-    @app.stroke "#666" if stroke
-    @app.fill color
-    @app.rect x*cell_size, y*cell_size, cell_size-1, cell_size-1
-    @app.stroke "#BBB" if stroke
-    @app.line x*cell_size+1, y*cell_size+1, x*cell_size+cell_size-1, y*cell_size
-    @app.line x*cell_size+1, y*cell_size+1, x*cell_size, y*cell_size+cell_size-1
-  end
-  
-  def render_flag(x, y)
-    @app.stroke "#000"
-    @app.line(x*cell_size+cell_size / 4 + 1, y*cell_size + cell_size / 5, x*cell_size+cell_size / 4 + 1, y*cell_size+cell_size / 5 * 4)
-    @app.fill "#A00"
-    @app.rect(x*cell_size+cell_size / 4+2, y*cell_size + cell_size / 5, 
-      cell_size / 3, cell_size / 4)
-  end
-  
-  def render_bomb(x, y)
-    render_cell(x, y)
-    if (game_over? or all_found?) then # draw bomb
-      if self[x, y].exploded then
-        render_cell(x, y, @app.rgb(0xFF, 0, 0, 0.5))
-      end
-      @app.nostroke
-      @app.fill @app.rgb(0, 0, 0, 0.8)
-      @app.oval(x*cell_size+3, y*cell_size+3, 13)
-      @app.fill "#333"
-      @app.oval(x*cell_size+5, y*cell_size+5, 7)
-      @app.fill "#AAA"
-      @app.oval(x*cell_size+6, y*cell_size+6, 3)
-      @app.fill @app.rgb(0, 0, 0, 0.8)
-      @app.stroke "#222"
-      @app.strokewidth 2
-      @app.oval(x*cell_size + cell_size / 2 + 2, y*cell_size + cell_size / 4 - 2, 2)
-      @app.oval(x*cell_size + cell_size / 2 + 4, y*cell_size + cell_size / 4 - 2, 1)
-      @app.strokewidth 1
-    end
-  end
-  
-  def render_number(x, y)
-    render_cell(x, y, "#999", false)
-    if self[x, y].number != 0 then
-      @app.nostroke
-      @app.para self[x, y].number.to_s, :left => x*cell_size + 3, :top => y*cell_size - 2, 
-        :font => '13px', :stroke => COLORS[self[x, y].number - 1]
-    end
-  end
-  
-  def paint
-    0.upto @h-1 do |y|
-      0.upto @w-1 do |x|
-        @app.nostroke
-        case self[x, y]
-          when EmptyCell then render_cell(x, y)
-          when Bomb then render_bomb(x, y)
-          when OpenCell then render_number(x, y)
-        end
-        render_flag(x, y) if has_flag?(x, y) && !(game_over? && bomb?(x, y))
-      end
-    end
-  end  
-
-  def bombs_left
-    @bombs - @field.flatten.compact.reject {|e| !e.flag }.size
-  end  
-
-  def all_found?
-    @field.flatten.compact.reject {|e| !e.is_a?(OpenCell) }.size + @bombs == @w*@h
-  end  
-
-  def reveal!(x, y)
-    return unless cell_exists?(x, y)
-    return unless self[x, y].is_a?(Field::OpenCell)
-    if flags_around(x, y) >= self[x, y].number then
-      (-1..1).each do |v|
-        (-1..1).each { |h| click!(x+h, y+v) unless (v==0 && h==0) or has_flag?(x+h, y+v) }
-      end
-    end      
-  end  
-  
-  private 
-  
-  def cell_exists?(x, y)
-    ((0...@w).include? x) && ((0...@h).include? y)
-  end
-  
-  def has_flag?(x, y)
-    return false unless cell_exists?(x, y)
-    return self[x, y].flag
-  end
-  
-  def bomb?(x, y)
-    cell_exists?(x, y) && (self[x, y].is_a? Bomb)
-  end
-  
-  def can_be_discovered?(x, y)
-    return false unless cell_exists?(x, y)
-    return false if self[x, y].flag
-    cell_exists?(x, y) && (self[x, y].is_a? EmptyCell) && !bomb?(x, y) && (bombs_around(x, y) == 0)
-  end  
-  
-  def open(x, y)
-    self[x, y] = OpenCell.new(bombs_around(x, y)) unless (self[x, y].is_a? OpenCell) or has_flag?(x, y)
-  end
-  
-  def neighbors
-    (-1..1).each do |col|
-      (-1..1).each { |row| yield row, col unless col==0 && row == 0 }
-    end  
-  end
-  
-  def discover(x, y)
-    open(x, y)
-    neighbors do |col, row|
-      cx, cy = x+row, y+col
-      next unless cell_exists?(cx, cy)
-      discover(cx, cy) if can_be_discovered?(cx, cy)
-      open(cx, cy)
-    end
-  end  
-
-  def count_neighbors
-    return 0 unless block_given?
-    count = 0
-    neighbors { |h, v| count += 1 if yield(h, v) }
-    count
-  end
-  
-  def bombs_around(x, y)
-    count_neighbors { |v, h| bomb?(x+h, y+v) }
-  end
-  
-  def flags_around(x, y)
-    count_neighbors { |v, h| has_flag?(x+h, y+v) }
-  end
-  
-  def die!(x, y)
-    self[x, y].exploded = true
-    @game_over = true
-  end
-
-  def plant_bomb(x, y)
-    self[x, y].is_a?(EmptyCell) ? self[x, y] = Bomb.new : false
-  end
-  
-  def plant_bombs
-    @bombs.times { redo unless plant_bomb(rand(@w), rand(@h)) }
-  end
-
-  def [](*args)
-    x, y = args
-    raise "Cell #{x}:#{y} does not exists!" unless cell_exists?(x, y)
-    @field[y][x]
-  end
-  
-  def []=(*args)
-    x, y, v = args
-    cell_exists?(x, y) ? @field[y][x] = v : false
-  end
-end
-
-Shoes.app :width => 730, :height => 450, :title => 'Minesweeper' do
-  def render_field
-    clear do
-      background rgb(50, 50, 90, 0.7)
-      flow :margin => 4 do
-        button("Beginner") { new_game :beginner }
-        button("Intermediate") { new_game :intermediate }
-        button("Expert") { new_game :expert }
-      end
-      stack do @status = para :stroke => white end
-      @field.paint
-      para "Left click - open cell, right click - put flag, middle click - reveal empty cells", :top => 420, :left => 0, :stroke => white,  :font => "11px"
-    end  
-  end
-  
-  def new_game level
-    @field = Field.new self, level
-    translate -@old_offset.first, -@old_offset.last unless @old_offset.nil?
-    translate @field.offset.first, @field.offset.last
-    @old_offset = @field.offset
-    render_field
-  end
-  
-  new_game :beginner
-  animate(5) { @status.replace "Time: #{@field.total_time.to_i} Bombs left: #{@field.bombs_left}" }
-  
-  click do |button, x, y|
-    next if @field.game_over? || @field.all_found?
-    fx, fy = ((x-@field.offset.first) / @field.cell_size).to_i, ((y-@field.offset.last) / @field.cell_size).to_i
-    @field.click!(fx, fy) if button == 1
-    @field.flag!(fx, fy) if button == 2
-    @field.reveal!(fx, fy) if button == 3
-
-    render_field
-    alert("Winner!\nTotal time: #{@field.total_time}") if @field.all_found?
-    alert("Bang!\nYou loose.") if @field.game_over?
-  end
-end