shoes 4.0.0.pre11 → 4.0.0.pre12

data/samples/expert_tetris.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+#==================================================================================================
+#
+# A Tetris game for Ruby Shoes
+#
+# Controls:
+#
+#  left/right - slide the piece horizontally
+#  up - rotate the piece 90 degrees clockwise
+#  down - drop the piece faster
+#  esc - quit the game
+#
+# For more details see http://codeincomplete.com/posts/2014/11/7/tetris_shoes/
+#
+
+#==================================================================================================
+# Game Constants
+#==================================================================================================
+
+WIDTH  = 300            # width  of tetris court (in pixels)
+HEIGHT = 600            # height of tetris court (in pixels)
+NX     = 10             # width  of tetris court (in blocks)
+NY     = 20             # height of tetris court (in blocks)
+DX     = WIDTH / NX     # pixel width  of a single tetris block
+DY     = HEIGHT / NY    # pixel height of a single tetris block
+FPS    = 60             # game animation frame rate (fps)
+
+PACE   = { start: 0.5, step: 0.005, min: 0.1 }.freeze # how long before a piece drops by 1 row (seconds)
+SCORE  = { line: 100, multiplier: 2 }.freeze          # score per line removed (100) and bonus multiplier when multiple lines cleared in a the same drop
+
+#==================================================================================================
+# The 7 Tetromino Types
+#==================================================================================================
+#
+# blocks: each element represents a rotation of the piece (0, 90, 180, 270)
+#         each element is a 16 bit integer where the 16 bits represent
+#         a 4x4 set of blocks, e.g. j.blocks[0] = 0x44C0
+#
+#             0100 = 0x4 << 3 = 0x4000
+#             0100 = 0x4 << 2 = 0x0400
+#             1100 = 0xC << 1 = 0x00C0
+#             0000 = 0x0 << 0 = 0x0000
+#                               ------
+#                               0x44C0
+#
+#  (see http://codeincomplete.com/posts/2011/10/10/javascript_tetris/)
+#
+
+I = { blocks: {up: 0x0F00, right: 0x2222, down: 0x00F0, left: 0x4444}, color: '#00FFFF', size: 4 }.freeze
+J = { blocks: {up: 0x44C0, right: 0x8E00, down: 0x6440, left: 0x0E20}, color: '#0000FF', size: 3 }.freeze
+L = { blocks: {up: 0x4460, right: 0x0E80, down: 0xC440, left: 0x2E00}, color: '#FF8000', size: 3 }.freeze
+O = { blocks: {up: 0xCC00, right: 0xCC00, down: 0xCC00, left: 0xCC00}, color: '#FFFF00', size: 2 }.freeze
+S = { blocks: {up: 0x06C0, right: 0x8C40, down: 0x6C00, left: 0x4620}, color: '#00FF00', size: 3 }.freeze
+T = { blocks: {up: 0x0E40, right: 0x4C40, down: 0x4E00, left: 0x4640}, color: '#8040FF', size: 3 }.freeze
+Z = { blocks: {up: 0x0C60, right: 0x4C80, down: 0xC600, left: 0x2640}, color: '#FF0000', size: 3 }.freeze
+
+#==================================================================================================
+# The Game Runner
+#==================================================================================================
+
+class Tetris
+  attr_reader :dt,       # time since the current active piece last dropped a row
+              :score,    # the current score
+              :lost,     # bool to indicate when the game is lost
+              :pace,     # current game pace - how long until the current piece drops a single row
+              :blocks,   # 2 dimensional array (NX*NY) represeting the tetris court - either empty block or occupied by a piece
+              :actions,  # queue of user inputs collected by the game loop
+              :bag,      # a collection of random pieces to be used
+              :current   # the current active piece
+
+  #----------------------------------------------------------------------------
+
+  def initialize
+    @dt      = 0
+    @score   = 0
+    @pace    = PACE[:start]
+    @blocks  = Array.new(NX) { Array.new(NY) } # awkward way to initialize an already sized 2 dimensional array
+    @actions = []
+    @bag     = new_bag
+    @current = random_piece
+  end
+
+  #----------------------------------------------------------------------------
+
+  def update(seconds)
+    action = actions.shift
+    case action
+    when :left   then move(:left)
+    when :right  then move(:right)
+    when :rotate then rotate
+    when :drop   then drop
+    end
+
+    @dt += seconds
+    if dt > pace
+      @dt = dt - pace
+      drop
+    end
+  end
+
+  #----------------------------------------------------------------------------
+
+  def move(direction)
+    nextup = current.move(direction)
+    if unoccupied(nextup)
+      choose_new_piece(nextup)
+      true
+    end
+  end
+
+  def rotate
+    nextup = current.rotate
+    if unoccupied(nextup)
+      choose_new_piece(nextup)
+      true
+    end
+  end
+
+  def drop
+    unless move(:down)
+      finalize_piece
+      reward_for_piece
+      remove_any_completed_lines
+      clear_pending_actions
+      choose_new_piece
+      lose if occupied(current)
+    end
+  end
+
+  #----------------------------------------------------------------------------
+
+  def unoccupied(piece)
+    !occupied(piece)
+  end
+
+  def occupied(piece)
+    piece.each_occupied_block do |x, y|
+      if x.negative? || (x >= NX) || y.negative? || (y >= NY) || blocks[x][y]
+        return true
+      end
+    end
+    false
+  end
+
+  #----------------------------------------------------------------------------
+
+  def finalize_piece
+    current.each_occupied_block { |x, y| blocks[x][y] = current.tetromino }
+  end
+
+  def choose_new_piece(piece = nil)
+    @current = piece || random_piece
+  end
+
+  def reward_for_piece
+    @score = score + 10
+  end
+
+  def reward_lines(lines)
+    @score = score + (SCORE[:line] * SCORE[:multiplier]**(lines - 1)) # e.g. 1: 100, 2: 200, 3: 400, 4: 800
+    @pace  = [pace - lines * PACE[:step], PACE[:min]].max
+  end
+
+  def clear_pending_actions
+    actions.clear
+  end
+
+  def lose
+    @lost = true
+  end
+
+  def lost?
+    @lost
+  end
+
+  def new_bag
+    [I, I, I, I, J, J, J, J, L, L, L, L, O, O, O, O, S, S, S, S, T, T, T, T, Z, Z, Z, Z].shuffle
+  end
+
+  def random_piece
+    @bag = new_bag if bag.empty?
+    Piece.new(bag.pop)
+  end
+
+  #----------------------------------------------------------------------------
+
+  def remove_any_completed_lines
+    lines = 0
+    NY.times do |y|
+      unless NX.times.any? { |x| blocks[x][y].nil? }
+        remove_line(y)
+        lines += 1
+      end
+    end
+    reward_lines(lines) unless lines.zero?
+  end
+
+  def remove_line(n)
+    n.downto(0) do |y|
+      NX.times do |x|
+        blocks[x][y] = y.zero? ? nil : blocks[x][y - 1]
+      end
+    end
+  end
+
+  #----------------------------------------------------------------------------
+
+  def each_occupied_block
+    NY.times do |y|
+      NX.times do |x|
+        yield x, y, blocks[x][y][:color] unless blocks[x][y].nil?
+      end
+    end
+  end
+end # class Tetris
+
+#==================================================================================================
+# A Game Piece
+#==================================================================================================
+
+class Piece
+  attr_reader :tetromino,  # the tetromino type
+              :direction,  # the rotation direction (:up, :down, :left, :right)
+              :x, :y       # the (x,y) position on the board
+
+  #----------------------------------------------------------------------------
+
+  def initialize(tetromino, x = nil, y = nil, direction = nil)
+    @tetromino = tetromino
+    @direction = direction || :up
+    @x         = x         || rand(NX - tetromino[:size]) # default to a random horizontal position (that fits)
+    @y         = y         || 0
+  end
+
+  #----------------------------------------------------------------------------
+
+  def rotate
+    newdir = case direction
+             when :left  then :up
+             when :up    then :right
+             when :right then :down
+             when :down  then :left
+             end
+    Piece.new(tetromino, x, y, newdir)
+  end
+
+  def move(direction)
+    case direction
+    when :right then Piece.new(tetromino, x + 1, y,     @direction)
+    when :left  then Piece.new(tetromino, x - 1, y,     @direction)
+    when :down  then Piece.new(tetromino, x,     y + 1, @direction)
+    end
+  end
+
+  #----------------------------------------------------------------------------
+
+  def each_occupied_block # a bit complex, for more details see - http://codeincomplete.com/posts/2011/10/10/javascript_tetris/
+    bit = 0b1000000000000000
+    row = 0
+    col = 0
+    blocks = tetromino[:blocks][direction]
+    until bit.zero?
+      yield x + col, y + row if (blocks & bit) == bit
+      col += 1
+      if col == 4
+        col = 0
+        row += 1
+      end
+      bit = bit >> 1
+    end
+  end
+end # class Piece
+
+#==================================================================================================
+# The SHOES application
+#==================================================================================================
+
+Shoes.app title: 'Tetris', width: WIDTH, height: HEIGHT do
+  game = Tetris.new
+
+  keypress do |k|
+    case k
+    when :left   then game.actions << :left
+    when :right  then game.actions << :right
+    when :down   then game.actions << :drop
+    when :up     then game.actions << :rotate
+    when :escape then quit
+    end
+  end
+
+  def block(x, y, color)
+    fill color
+    rect(x * DX, y * DY, DX, DY)
+  end
+
+  last = Time.now
+  animate = animate FPS do
+    now = Time.now
+
+    game.update(now - last)
+    clear
+
+    game.each_occupied_block do |x, y, color|
+      block(x, y, color)
+    end
+
+    game.current.each_occupied_block do |x, y|
+      block(x, y, game.current.tetromino[:color])
+    end
+
+    if game.lost?
+      banner "Game Over", align: 'center', stroke: black
+      animate.stop
+    else
+      subtitle "Score: #{format('%6.6d', game.score)}", stroke: green, align: 'right'
+    end
+
+    last = now
+  end
+end
+
+#==================================================================================================

data/samples/good_arc.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+#
+# a translation from a processing example
+# http://vormplus.be/weging/an-introduction-to-processing/
+#
+Shoes.app width: 420, height: 420, resizable: false do
+  stage = 0
+  wide = 3
+  sw = 1.0
+  basesize = 600
+  step = 60
+  stroke white(100)
+  nofill
+
+  animate 40 do |i|
+    stage = rand(1...8) if (i % 40).zero?
+    if wide.abs < 0.1
+      wide = if stage == 6
+               -0.1
+             else
+               0.1
+             end
+    end
+    rotation = -(Shoes::HALF_PI / wide)
+    clear do
+      background gray(240)
+      10.times do |j|
+        strokewidth sw * j
+        size = (basesize + step * j) / 3
+        top = (height - size) / 2
+        left = (width - size) / 2
+        arc top, left,
+            size, size,
+            rotation * j,
+            rotation * j + Shoes::TWO_PI - Shoes::HALF_PI
+      end
+    end
+
+    case stage
+    when 1 then wide -= 0.1
+    when 2 then wide += 0.1
+    when 3 then basesize -= 1
+    when 4 then basesize += 2
+    when 5 then sw += 0.1
+    when 6 then sw = [sw - 0.1, 0.1].max
+    when 7 then step += 2
+    else
+      step -= 1
+    end
+  end
+end

data/samples/good_bounce.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+# The Shoes logo/icon bounces on the screen. The logo/icon responds to menu options and if clicked on.
+xspeed = 10
+yspeed = 6
+xdir = 1
+ydir = 1
+
+Shoes.app width: 300, height: 300 do
+  a = nil
+  button('toggle') { a.toggle }
+  button('stop') { a.stop }
+  button('start') { a.start }
+  button('remove') { a.remove }
+  img = image File.join(Shoes::DIR, 'static/shoes-icon.png'),
+              click: ->() { alert "You're soooo quick!" }
+
+  x = 150
+  y = 150
+  size = [128, 128]
+  pause = 0
+
+  a = animate 24 do |n|
+    unless pause == n
+      x += xspeed * xdir
+      y += yspeed * ydir
+
+      xdir *= -1 if x > 300 - size[0] || x.negative?
+      ydir *= -1 if y > 300 - size[1] || y.negative?
+
+      img.move x.to_i, y.to_i
+    end
+    pause = n
+  end
+end

data/samples/good_clock.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+#
+# Shoes Clock by Thomas Bell
+# posted to the Shoes mailing list on 04 Dec 2007
+#
+Shoes.app height: 260, width: 250 do
+  @radius = 90
+  @centerx = 126
+  @centery = 140
+  animate(8) do
+    @time = Time.now
+    clear do
+      draw_background
+      stack do
+        background black
+        para @time.strftime("%a"),
+             span(@time.strftime(" %b %d, %Y "), stroke: "#ccc"),
+             strong(@time.strftime("%I:%M"), stroke: white),
+             @time.strftime(".%S"), align: "center", stroke: "#666",
+                                    margin: 4
+      end
+      clock_hand @time.sec + (@time.usec * 0.000001), 2, 30, red
+      clock_hand @time.min + (@time.sec / 60.0), 5
+      clock_hand @time.hour + (@time.min / 60.0), 8, 6
+    end
+  end
+  def draw_background
+    background rgb(230, 240, 200)
+
+    fill white
+    stroke black
+    strokewidth 4
+    oval @centerx - 102, @centery - 102, 204, 204
+
+    fill black
+    nostroke
+    oval @centerx - 5, @centery - 5, 10, 10
+
+    stroke black
+    strokewidth 1
+    line(@centerx, @centery - 102, @centerx, @centery - 95)
+    line(@centerx - 102, @centery, @centerx - 95, @centery)
+    line(@centerx + 95, @centery, @centerx + 102, @centery)
+    line(@centerx, @centery + 95, @centerx, @centery + 102)
+  end
+
+  def clock_hand(time, sw, unit = 30, color = black)
+    radius_local = unit == 30 ? @radius : @radius - 15
+    x = radius_local * Math.sin(time * Math::PI / unit)
+    y = radius_local * Math.cos(time * Math::PI / unit)
+    stroke color
+    strokewidth sw
+    line(@centerx, @centery, @centerx + x, @centery - y)
+  end
+end