shoes 4.0.0.pre2 → 4.0.0.pre3

data/samples/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.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

data/samples/expert-othello-adjusted.rb

@@ -1,325 +0,0 @@
-# The original is Red Shoes built-in sample: expert-othello.rb
-# A little bit edited for Green Shoes.
-
-# 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
-  SPACE        = ' ' * 57
-
-  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 width: width-5, height: 50 do
-      if GAME.current_player==GAME.p1
-        background yellow
-        border black, strokewidth: 10
-        para strong("Player 1 (#{GAME.current_player.color}) turn"), margin: [20, 15, 0, 0]
-      else
-        background white
-        border black, strokewidth: 10
-        undo = GAME.board_history.empty? ? nil : link("Undo last move"){ GAME.undo!; draw_board }
-        para strong("Player 1"), SPACE, undo, margin: [20, 15, 0, 0]
-      end
-    end
-  end
-
-  def draw_player_2(first_turn=false)
-    stack width: width-5, height: 50 do
-      if GAME.current_player==GAME.p2
-        background yellow
-        border black, strokewidth: 10
-        para strong("Player 2 (#{GAME.current_player.color}) turn"), margin: [20, 15, 0, 0]
-      else
-        background white
-        border black, strokewidth: 10
-        undo = GAME.board_history.empty? ? nil : link("Undo last move"){ GAME.undo!; draw_board }
-        para strong("Player 2"), SPACE, undo, margin: [20, 15, 0, 0]
-      end
-    end
-  end
-
-
-  def draw_board
-    clear do
-      background black
-      draw_player_1
-
-      stack width: width, height: 500 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 + 10
-            top = top - TOP_OFFSET + 50
-            fill rgb(0, 255, 0)
-            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
-end
-
-
-Shoes.app width: 520, height: 600 do
-  extend Othello
-  GAME = Othello::Game.new
-
-  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