shoesgem 0.1424.0

data/shoes/samples/expert-minesweeper.rb

@@ -0,0 +1,267 @@
+#
+# 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

data/shoes/samples/expert-othello.rb

@@ -0,0 +1,319 @@
+# Othello
+# by tieg
+# 1/13/08
+# with help: DeeJay, Ryan M. from mailing list
+#
+# FIXME bug if it memorizes it but it's not a valid move
+#
+module Othello
+
+  PIECE_WIDTH  = 62
+  PIECE_HEIGHT = 62
+  TOP_OFFSET = 47
+  LEFT_OFFSET = 12
+
+  class Game
+    BOARD_SIZE = [8,8]
+
+    attr_accessor :p1, :p2, :board, :board_history
+        
+    def initialize
+      @board_history = []
+      @p1            = Player.new(:black, pieces_per_player)
+      @p2            = Player.new(:white, pieces_per_player)
+      @board         = new_board
+      lay_initial_pieces
+    end
+
+    def next_turn(check_available_moves=true)
+      @current_player = next_player
+      if check_available_moves && skip_turn?
+        # FIXME Possible infinite loop if neither player has a good move?
+        next_turn
+        raise "Player #{@current_player.piece} (#{@current_player.color}) has no available moves. Player #{next_player.piece}'s (#{next_player.color}) turn."
+      end
+    end
+
+    def current_player
+      @current_player ||= @p1
+    end
+
+    def next_player
+      current_player == @p1 ? @p2 : @p1
+    end
+
+    # Build the array for the board, with zero-based arrays.
+    def new_board
+      Array.new(BOARD_SIZE[0]) do # build each cols L to R
+        Array.new(BOARD_SIZE[1]) do # insert cells in each col
+          0
+        end
+      end
+    end
+    
+    # Lay the initial 4 pieces in the middle
+    def lay_initial_pieces
+      lay_piece([4, 3], false)
+      next_turn(false)
+      lay_piece([3, 3], false)
+      next_turn(false)
+      lay_piece([3, 4], false)
+      next_turn(false)
+      lay_piece([4, 4], false)
+      next_turn(false)
+    end
+    
+    def lay_piece(c=[0,0], check_adjacent_pieces=true)
+      memorize_board
+      piece = current_player.piece
+      opp_piece = current_player.opp_piece
+      raise "Spot already taken." if board_at(c) != 0
+      if check_adjacent_pieces
+        pieces_to_change = []
+        pieces_to_change << check_direction(c, [ 0, 1], piece, opp_piece) # N
+        pieces_to_change << check_direction(c, [ 1, 1], piece, opp_piece) # NE
+        pieces_to_change << check_direction(c, [ 1, 0], piece, opp_piece) # E
+        pieces_to_change << check_direction(c, [ 1,-1], piece, opp_piece) # SE
+        pieces_to_change << check_direction(c, [ 0,-1], piece, opp_piece) # S
+        pieces_to_change << check_direction(c, [-1,-1], piece, opp_piece) # SW
+        pieces_to_change << check_direction(c, [-1, 0], piece, opp_piece) # W
+        pieces_to_change << check_direction(c, [-1, 1], piece, opp_piece) # NW
+        raise "You must move to a spot that will turn your opponent's piece." if pieces_to_change.compact.all? { |a| a.empty? }
+        pieces_to_change.compact.each { |direction| direction.each { |i| @board[i[0]][i[1]] = piece } }
+      end
+      current_player.pieces -= 1
+      @board[c[0]][c[1]] = piece
+      current_winner = calculate_current_winner
+      raise "Game over. Player #{current_winner.piece} wins with #{current_winner.pieces_on_board} pieces!" if @p1.pieces + @p2.pieces == 0
+    end
+    
+    def skip_turn?
+      possibles = []
+      @board.each_with_index { |col,col_index| 
+        col.each_with_index { |cell,row_index| 
+          return false if possible_move?([col_index,row_index])
+        } 
+      }
+      true
+    end
+    
+    def possible_move?(c=[0,0])
+      return nil if board_at(c) != 0
+      possible_moves = []
+      piece = current_player.piece
+      opp_piece = current_player.opp_piece
+      pieces_to_change = []
+      pieces_to_change << check_direction(c, [ 0, 1], piece, opp_piece) # N
+      pieces_to_change << check_direction(c, [ 1, 1], piece, opp_piece) # NE
+      pieces_to_change << check_direction(c, [ 1, 0], piece, opp_piece) # E
+      pieces_to_change << check_direction(c, [ 1,-1], piece, opp_piece) # SE
+      pieces_to_change << check_direction(c, [ 0,-1], piece, opp_piece) # S
+      pieces_to_change << check_direction(c, [-1,-1], piece, opp_piece) # SW
+      pieces_to_change << check_direction(c, [-1, 0], piece, opp_piece) # W
+      pieces_to_change << check_direction(c, [-1, 1], piece, opp_piece) # NW
+      return nil if pieces_to_change.compact.all? { |a| a.empty? }
+      true
+    end
+    
+    def memorize_board
+      dup_board = new_board
+      dup_board = []
+      @board.each do |col|
+        dup_board << col.dup
+      end
+      @board_history << { :player => current_player, :board => dup_board }
+    end
+
+    def undo!
+      last_move = @board_history.pop
+      @board = last_move[:board]
+      @current_player = last_move[:player]
+      @current_player.pieces += 1
+    end
+
+    def calculate_current_winner
+      @p1.pieces_on_board, @p2.pieces_on_board = 0, 0
+      @board.each { |row| 
+        row.each { |cell|
+          if cell == 1
+            @p1.pieces_on_board += 1
+          else 
+            @p2.pieces_on_board += 1
+          end
+        }
+      }
+      @p1.pieces_on_board > @p2.pieces_on_board ? @p1 : @p2
+    end
+
+    def check_direction(c, dir, piece, opp_piece)
+      c_adjacent = next_in_direction(c.dup, dir)
+      c_last = nil
+      pieces_in_between = []
+      # Find the last piece if there is one.
+      while(valid_location?(c_adjacent))
+        if board_at(c_adjacent) == opp_piece
+          pieces_in_between << c_adjacent.dup
+        elsif board_at(c_adjacent) == piece && pieces_in_between.size > 0
+          c_last = c_adjacent
+          break
+        else
+          break
+        end
+        c_adjacent = next_in_direction(c_adjacent, dir)
+      end
+
+      pieces_in_between.empty? || c_last.nil? ? nil : pieces_in_between
+    end
+    
+    # Find the value of the board at the given coordinate.
+    def board_at(c)
+      @board[c[0]][c[1]]
+    end
+
+    # Is this a valid location on board?
+    def valid_location?(c=[1,1])
+      c[0] >= 0 && c[1] >= 0 && c[0] < BOARD_SIZE[0] && c[1] < BOARD_SIZE[1]
+    end
+
+    # Perform the operations to get the next spot in the appropriate direction
+    def next_in_direction(c, dir)
+      c[0] += dir[0]
+      c[1] += dir[1]
+      c
+    end
+
+    private
+    def pieces_per_player
+      total_squares / 2
+    end
+    
+    # The total number of squares
+    def total_squares
+      BOARD_SIZE[0] * BOARD_SIZE[1]
+    end
+
+    class Player
+      attr_accessor :pieces, :color, :pieces_on_board
+
+      def initialize(color=:black,pieces=0)
+        @pieces = pieces
+        @pieces_on_board = 0 # used only in calculating winner
+        @color = color
+      end
+      
+      def piece
+        color == :black ? 1 : 2
+      end
+      
+      def opp_piece
+        color == :black ? 2 : 1
+      end
+    end 
+  end
+
+  def draw_player_1(first_turn=false)
+    stack :margin => 10 do
+      if GAME.current_player==GAME.p1
+        background yellow
+        para span("Player 1 (#{GAME.current_player.color}) turn", :stroke => black, :font => "Trebuchet 20px bold"), :margin => 4
+      else
+        background white
+        para span("Player 1", :stroke => black, :font => "Trebuchet 10px bold"), :margin => 4
+
+        button("Undo last move", :top => 0, :left => -150) { GAME.undo!; draw_board } unless GAME.board_history.empty?
+      end
+    end
+  end
+
+  def draw_player_2(first_turn=false)
+    stack :top => 550, :left => 0, :margin => 10 do
+      if GAME.current_player==GAME.p2 
+        background yellow
+        para span("Player 2's (#{GAME.current_player.color}) turn", :stroke => black, :font => "Trebuchet 20px bold"), :margin => 4
+      else
+        background white
+        para span("Player 2", :stroke => black, :font => "Trebuchet 10px bold"), :margin => 4
+
+        button("Undo last move", :top => 0, :left => -150) { GAME.undo!; draw_board } unless GAME.board_history.empty?
+      end
+    end
+  end
+
+
+  def draw_board
+    clear do
+      background black
+      draw_player_1
+      stack :margin => 10 do
+        fill rgb(0, 190, 0)
+        rect :left => 0, :top => 0, :width => 495, :height => 495
+
+        GAME.board.each_with_index do |col, col_index|
+          col.each_with_index do |cell, row_index|
+            left, top = left_top_corner_of_piece(col_index, row_index)
+            left = left - LEFT_OFFSET
+            top = top - TOP_OFFSET
+            fill rgb(0, 440, 0, 90)
+            strokewidth 1
+            stroke rgb(0, 100, 0)
+            rect :left => left, :top => top, :width => PIECE_WIDTH, :height => PIECE_HEIGHT
+
+            if cell != 0
+              strokewidth 0
+              fill (cell == 1 ? rgb(100,100,100) : rgb(155,155,155))
+              oval(left+3, top+4, PIECE_WIDTH-10, PIECE_HEIGHT-10)
+
+              fill (cell == 1 ? black : white)
+              oval(left+5, top+5, PIECE_WIDTH-10, PIECE_HEIGHT-10)
+            end
+          end
+        end
+      end
+      draw_player_2
+    end
+  end
+
+  def left_top_corner_of_piece(a,b)
+    [(a*PIECE_WIDTH+LEFT_OFFSET), (b*PIECE_HEIGHT+TOP_OFFSET)]
+  end
+
+  def right_bottom_corner_of_piece(a,b)
+    left_top_corner_of_piece(a,b).map { |coord| coord + PIECE_WIDTH }
+  end
+
+  def find_piece(x,y)
+    GAME.board.each_with_index { |row_array, row| 
+      row_array.each_with_index { |col_array, col| 
+        left, top = left_top_corner_of_piece(col, row).map { |i| i - 5}
+        right, bottom = right_bottom_corner_of_piece(col, row).map { |i| i -5 }
+        return [col, row] if x >= left && x <= right && y >= top && y <= bottom
+      } 
+    }
+    return false
+  end
+
+  GAME = Othello::Game.new
+end
+
+
+Shoes.app :width => 520, :height => 600 do
+  extend Othello
+
+  draw_board
+  
+  click { |button, x, y| 
+    if coords = find_piece(x,y)
+      begin
+        GAME.lay_piece(coords)
+        GAME.next_turn
+        draw_board
+      rescue => e
+        draw_board
+        alert(e.message)
+      end
+    else
+      # alert("Not a piece.")
+    end
+  }
+end
+

data/shoes/samples/expert-pong.rb

@@ -0,0 +1,62 @@
+#
+# Pong in Shoes
+# a clone of http://billmill.org/pong.html
+# and shoes is at http://shoooes.net
+#
+# This is just for kicks -- I'm very fond of NodeBox as well.
+#
+# There's a slightly different approach in Shoes: rather than
+# redrawing the shapes, you can move the shapes around as objects.
+# Yeah, see, notice how @you, @comp and @ball are used.
+#
+Shoes.app :width => 400, :height => 400, :resizable => false do
+  paddle_size = 75
+  ball_diameter = 20
+  vx, vy = [3, 4]
+  compuspeed = 10
+  bounce = 1.2
+
+  # set up the playing board
+  nostroke and background white
+  @ball = oval 0, 0, ball_diameter, :fill => "#9B7"
+  @you, @comp = [app.height-4, 0].map {|y| rect 0, y, paddle_size, 4, :curve => 2}
+
+  # animates at 40 frames per second
+  @anim = animate 40 do
+
+    # check for game over
+    if @ball.top + ball_diameter < 0 or @ball.top > app.height
+      para strong("GAME OVER", :size => 32), "\n",
+        @ball.top < 0 ? "You win!" : "Computer wins", :top => 140, :align => 'center'
+      @ball.hide and @anim.stop
+    end
+
+    # move the @you paddle, following the mouse
+    @you.left = mouse[1] - (paddle_size / 2)
+    nx, ny = (@ball.left + vx).to_i, (@ball.top + vy).to_i
+
+    # move the @comp paddle, speed based on `compuspeed` variable
+    @comp.left += 
+      if nx + (ball_diameter / 2) > @comp.left + paddle_size;  compuspeed
+      elsif nx < @comp.left;                                  -compuspeed
+      else 0 end
+
+    # if the @you paddle hits the ball
+    if ny + ball_diameter > app.height and vy > 0 and
+        (0..paddle_size).include? nx + (ball_diameter / 2) - @you.left
+      vx, vy = (nx - @you.left - (paddle_size / 2)) * 0.25, -vy * bounce
+      ny = app.height - ball_diameter
+    end
+
+    # if the @comp paddle hits the ball
+    if ny < 0 and vy < 0 and
+        (0..paddle_size).include? nx + (ball_diameter / 2) - @comp.left
+      vx, vy = (nx - @comp.left - (paddle_size / 2)) * 0.25, -vy * bounce
+      ny = 0
+    elsif nx + ball_diameter > app.width or nx < 0
+      vx = -vx
+    end
+
+    @ball.move nx, ny
+  end
+end