shoes 4.0.0.pre2 → 4.0.0.pre3

data/samples/expert-othello.rb

@@ -1,318 +0,0 @@
-# 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
-end
-
-GAME = Othello::Game.new
-
-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/samples/expert-pong.rb

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

data/samples/expert-snake.rb

@@ -1,78 +0,0 @@
-Shoes.app title: 'Snake Game v0.1' do
-  def game_start
-    @score = para 'Score:', stroke: white
-    @pos = {up: [0, -10], down: [0, 10], left: [-10, 0], right: [10, 0]}
-    @rx, @ry = proc{20 + 10*rand(56)}, proc{40 + 10*rand(44)}
-
-    create_food
-
-    create_bricks
-
-    create_initial_snake
-
-    dir = :left
-    @run  = animate 5 do
-      check_food
-      go dir
-      @score.text = "Score: #{@snake.length * 10}"
-      brick? @snake[0]
-    end
-    keypress{|k| dir = k if @pos.keys.include? k}
-  end
-
-  def go k
-    x, y = @pos[k]
-    @snake.unshift @snake.pop
-    n = @snake.length > 1 ? 1 : 0
-    @snake[0].move @snake[n].left + x, @snake[n].top + y
-    @snake[0].style stroke: red
-    @snake[1].style stroke: white if n > 0
-  end
-
-  def check_food
-    (@snake << rect(0, 0, 10, 10)) if eat? @snake[0]
-  end
-
-  def eat? s
-    @foods.each_with_index do |f, i|
-      (f.move @rx[], @ry[]; return true) if f.left == s.left and f.top == s.top
-    end
-    return false
-  end
-
-  def brick? s
-    @bricks.each do |b|
-      (@run.remove; alert 'Game Over. ') if b.left == s.left and b.top == s.top
-    end
-  end
-
-  def create_food
-    @foods = []
-    stroke lime
-    50.times{@foods << rect(@rx[], @ry[], 10, 10)}
-  end
-
-  def create_bricks
-    @bricks = []
-    stroke deepskyblue; fill blue
-
-    50.times{@bricks << rect(@rx[], @ry[], 10, 10)}
-
-    20.step(570, 10){|n| @bricks << rect(n, 40, 10, 10) << rect(n, 470, 10, 10)}
-
-    40.step(470, 10){|n| @bricks << rect(10, n, 10, 10) << rect(570, n, 10, 10)}
-  end
-
-  def create_initial_snake
-    @snake = []
-    stroke white; nofill
-
-    @snake << rect(300, 100, 10, 10)
-
-    @snake[0].style stroke: red
-  end
-
-  background black
-
-  game_start
-end