shoes 3.0.1 → 4.0.0.pre1

data/samples/expert-game-of-life.rb

@@ -0,0 +1,243 @@
+# Simple Game of Life with Shoes
+# by fuksito
+# vitaliy@yanchuk.me
+
+
+class Cell
+  WIDTH = 15
+  attr_accessor :live, :next_state, :y, :x, :neighbours, :live_neighbours, :app, :shoes_cell
+
+  def initialize(y, x, app, world)
+    @live = false
+    @next_state = false
+    @y = y
+    @x = x
+    @app = app
+    @world = world
+    @shoes_cell = @app.rect(left: WIDTH * y, top: WIDTH * x, width: WIDTH)
+    @shoes_cell.click{ toggle_state }
+  end
+
+  def live?
+    @live
+  end
+
+  def dead?
+    !@live
+  end
+
+  def die!
+    @next_state = false
+    @world.changed_cells.push(self)
+  end
+
+  def alive!
+    @next_state = true
+    @world.changed_cells.push(self)
+  end
+
+  def toggle_state
+    @next_state = !@live
+    set_next_state
+    draw
+  end
+
+  def set_next_state
+    if @live = @next_state
+      @world.live_cells.push(self)
+    else
+      cell_index = @world.live_cells.index(self)
+      if cell_index
+        @world.live_cells.delete_at(cell_index)
+      end
+    end
+  end
+  
+  def draw
+    @shoes_cell.style(fill: live? ? '#000' : '#fff')
+  end
+
+  def iterate
+    live_cells_count = @neighbours.count{|c| c.live? }
+    if live?
+      if live_cells_count < 2 || live_cells_count > 3
+        die!
+      end
+    else
+      if live_cells_count == 3
+        alive!
+      end
+    end
+  end
+end
+
+class World
+  attr_accessor :board, :width, :height, :live_cells, :changed_cells
+
+  def initialize(width, height, app)
+    @board = []
+    @width = width
+    @height = height
+    @app = app
+    @live_cells = []
+    @changed_cells = []
+    create_board
+  end
+
+  def create_board
+    @height.times do |y|
+      @board[y] = []
+      @width.times do |x|
+        @board[y][x] = Cell.new(y, x, @app, self)
+      end
+    end
+    cells.each do |cell|
+      cell.neighbours = cell_neighbours(cell.y, cell.x)
+    end
+    draw
+  end
+
+  def cells
+    @cells ||= @board.flatten
+  end
+
+  def actual_cells
+    (@live_cells.map(&:neighbours).flatten + @live_cells).uniq
+  end
+
+  def draw
+    cells.each{|c| c.draw }
+  end
+
+  def tick
+    @changed_cells = []
+    actual_cells.each{|c| c.iterate }.each{|c| c.set_next_state }
+    @changed_cells.each{|c| c.draw }
+  end
+
+  def clear
+    live_cells.each do |cell|
+      cell.live = false
+      cell.next_state = false
+      cell.draw
+    end
+  end
+
+  def cell_neighbours(y,x)
+    result = []
+    top_row = y - 1
+    left_col = x - 1
+    right_col = x + 1
+    bottom_row = y + 1
+
+    if top_row >= 0 && left_col >= 0
+      result << @board[y-1][x-1]
+    end
+
+    if top_row >= 0
+      result << @board[y-1][x]
+    end
+
+    if top_row >= 0 && right_col < @width
+      result << @board[y-1][x+1]
+    end
+
+    if left_col >= 0
+      result << @board[y][x-1]
+    end
+
+    if right_col < @width
+      result << @board[y][x+1]
+    end
+
+    if bottom_row < @height && left_col >= 0
+      result << @board[y+1][x-1]
+    end
+
+    if bottom_row < @height
+      result << @board[y+1][x]
+    end
+
+    if bottom_row < @height && right_col < @width
+      result << @board[y+1][x+1]
+    end
+
+    result.compact
+  end
+
+  def add_specie(*cells)
+    cells.each do |y,x|
+      @board[y][x].toggle_state
+    end
+  end
+
+  def add_glinder
+    add_specie [4,2], [4,3], [4,4], [3,4], [2,3]
+  end
+
+  def add_spaceship
+    add_specie [12,3], [12,6], [13,7], [14,3], [14,7], [15,4], [15,5], [15,6], [15,7]
+  end
+
+  def add_diehard
+    add_specie [18,12], [12,13], [13,13], [13,14], [17,14], [18,14], [19,14]
+  end
+end
+
+Shoes.app(title: "The Game of Life", width: 800, height: 620, resizable: false) do
+  background white
+  @animate = false
+  stack(margin: 10) do |board_holder|
+    @new_world = World.new(40, 40, self)
+    animate(10) do |frame|
+      if @animate
+        @new_world.tick
+      end
+    end
+  end
+
+  def play
+    @animate = true
+    @run_button.style(displace_top: -100)
+    @stop_button.style(displace_top: 0)
+  end
+
+  def stop
+    @animate = false
+    @stop_button.style(displace_top: -100)
+    @run_button.style(displace_top: 0)
+  end
+
+  def clear
+    stop
+    @new_world.clear
+  end
+
+  flow(displace_left: 650) do
+    @run_button  = button('Run',  displace_top: 0,                         width: 100){ play }
+    @stop_button = button('Stop', displace_top: -100, displace_left: -100, width: 100){ stop }
+  end
+
+  stack(displace_left: 650) do
+    button('Clear', width: 100) do
+      clear
+    end
+
+    para "Species"
+    button('Glinder', width: 100) do
+      clear
+      @new_world.add_glinder
+    end
+
+    button('Spaceship', width: 100) do
+      clear
+      @new_world.add_spaceship
+    end
+
+    button('Diehard', width: 100) do
+      clear
+      @new_world.add_diehard
+    end
+  end
+
+end

data/samples/expert-irb-adjusted.rb

@@ -0,0 +1,110 @@
+require 'irb/ruby-lex'
+require 'stringio'
+
+class MimickIRB < RubyLex
+  attr_accessor :started
+
+  class Continue < StandardError; end
+  class Empty < StandardError; end
+
+  def initialize
+    super
+    set_input(StringIO.new)
+  end
+
+  def run(str)
+    obj = nil
+    @io << str
+    @io.rewind
+    unless l = lex
+      raise Empty if @line == ''
+    else
+      case l.strip
+      when "reset"
+        @line = ""
+      when "time"
+        @line = "puts %{You started \#{IRBalike.started.since} ago.}"
+      else
+        @line << l << "\n"
+        if @ltype or @continue or @indent > 0
+          raise Continue
+        end
+      end
+    end
+    unless @line.empty?
+      obj = eval @line, TOPLEVEL_BINDING, "(irb)", @line_no
+    end
+    @line_no += @line.scan(/\n/).length
+    @line = ''
+    @exp_line_no = @line_no
+
+    @indent = 0
+    @indent_stack = []
+
+    $stdout.rewind
+    output = $stdout.read
+    $stdout.truncate(0)
+    $stdout.rewind
+    [output, obj]
+  rescue Object => e
+    case e when Empty, Continue
+    else @line = ""
+    end
+    raise e
+  ensure
+    set_input(StringIO.new)
+  end
+
+end
+
+CURSOR = ">>"
+IRBalike = MimickIRB.new
+$stdout = StringIO.new
+
+Shoes.app do
+  @str, @cmd = [CURSOR + " "], ""
+  background "#555"
+  @scroll = stack do
+    background "#555"
+    stack width: 1.0, height: 50 do
+      para "Interactive Ruby ready.", fill: white, stroke: red
+    end
+    @console = para *@str, font: "Lucida Console", stroke: "#dfa"
+    @console.cursor = -1
+  end
+  keypress do |k|
+    case k
+    when "\n"
+      begin
+        out, obj = IRBalike.run(@cmd + ';')
+        @str += ["#@cmd\n",
+          fg("#{out}=> #{obj.inspect}\n", "#fda"),
+          "#{CURSOR} "]
+        @cmd = ""
+      rescue MimickIRB::Empty
+      rescue MimickIRB::Continue
+        @str += ["#@cmd\n.. "]
+        @cmd = ""
+      rescue Object => e
+        @str += ["#@cmd\n", fg("#{e.class}: #{e.message}\n", "#fcf"),
+          "#{CURSOR} "]
+        @cmd = ""
+      end
+    when String
+      @cmd += k
+    when :backspace
+      @cmd.slice!(-1)
+    when :tab
+      @cmd += "  "
+    when :alt_q
+      exit
+    when :alt_c
+      self.clipboard = @cmd
+    when :alt_v
+      @cmd += self.clipboard
+    end
+    @console.replace *(@str + [@cmd])
+    tmp = @scroll.height - app.height
+    @scroll.scroll_top = tmp > 0 ? tmp : 0
+  end
+end

data/samples/expert-irb.rb

@@ -63,15 +63,15 @@ $stdout = StringIO.new
 
 Shoes.app do
   @str, @cmd = [CURSOR + " "], ""
-  stack :width => 1.0, :height => 1.0 do
+  stack width: 1.0, height: 1.0 do
     background "#555"
-    stack :width => 1.0, :height => 50 do
-      para "Interactive Ruby ready.", :fill => white, :stroke => red
+    stack width: 1.0, height: 50 do
+      para "Interactive Ruby ready.", fill: white, stroke: red
     end
     @scroll =
-      stack :width => 1.0, :height => -50, :scroll => true do
+      stack width: 1.0, height: -50, scroll: true do
         background "#555"
-        @console = para @str, :font => "Monospace 12px", :stroke => "#dfa"
+        @console = para @str, font: "Monospace 12px", stroke: "#dfa"
         @console.cursor = -1
       end
   end
@@ -81,7 +81,7 @@ Shoes.app do
       begin
         out, obj = IRBalike.run(@cmd + ';')
         @str += ["#@cmd\n",
-          span("#{out}=> #{obj.inspect}\n", :stroke => "#fda"),
+          span("#{out}=> #{obj.inspect}\n", stroke: "#fda"),
           "#{CURSOR} "]
         @cmd = ""
       rescue MimickIRB::Empty
@@ -89,7 +89,7 @@ Shoes.app do
         @str += ["#@cmd\n.. "]
         @cmd = ""
       rescue Object => e
-        @str += ["#@cmd\n", span("#{e.class}: #{e.message}\n", :stroke => "#fcf"),
+        @str += ["#@cmd\n", span("#{e.class}: #{e.message}\n", stroke: "#fcf"),
           "#{CURSOR} "]
         @cmd = ""
       end

data/samples/expert-minesweeper-adjusted.rb

@@ -0,0 +1,272 @@
+#
+# 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+x*cell_size, $y+y*cell_size, cell_size-1, cell_size-1
+    @app.stroke "#BBB" if stroke
+    @app.line $x+x*cell_size+1, $y+y*cell_size+1, $x+x*cell_size+cell_size-1, $y+y*cell_size
+    @app.line $x+x*cell_size+1, $y+y*cell_size+1, $x+x*cell_size, $y+y*cell_size+cell_size-1
+  end
+
+  def render_flag(x, y)
+    @app.stroke "#000"
+    @app.line($x+x*cell_size+cell_size / 4 + 1, $y+y*cell_size + cell_size / 5, $x+x*cell_size+cell_size / 4 + 1, $y+y*cell_size+cell_size / 5 * 4)
+    @app.fill "#A00"
+    @app.rect($x+x*cell_size+cell_size / 4+2, $y+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+x*cell_size+3, $y+y*cell_size+3, 13)
+      @app.fill "#333"
+      @app.oval($x+x*cell_size+5, $y+y*cell_size+5, 7)
+      @app.fill "#AAA"
+      @app.oval($x+x*cell_size+6, $y+y*cell_size+6, 3)
+      @app.fill @app.rgb(0, 0, 0, 0.8)
+      @app.stroke "#222"
+      @app.strokewidth 2
+      @app.oval($x+x*cell_size + cell_size / 2 + 2, $y+y*cell_size + cell_size / 4 - 2, 2)
+      @app.oval($x+x*cell_size + cell_size / 2 + 4, $y+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.nofill
+      @app.oval($x+x*cell_size + 3, $y+y*cell_size - 2, 10)
+      @app.para self[x, y].number.to_s, left: $x+x*cell_size + 3, top: $y+y*cell_size - 2,
+        size: 13, 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
+        flow do
+          button("Beginner") { new_game :beginner }
+          button("Intermediate") { new_game :intermediate }
+          button("Expert") { new_game :expert }
+        end
+      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,  size: 11
+    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
+    $x, $y = @field.offset.first, @field.offset.last
+    render_field
+  end
+
+  new_game :beginner
+  every { @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.reveal!(fx, fy) if button == 2
+    @field.flag!(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