bettys 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c28f8fe1ef7934ce8e124984faf7e16e944a349766d861aa02a170ac83f5306c
+  data.tar.gz: b36e4909cbde89fca7faf87824aa101b25f08ee839ff13121fc8b11c5108570a
+SHA512:
+  metadata.gz: 976bb1f0f404d7ecdface6e19d629649514cb253be6ab936200ad46af152cfbb8a33179483b1605fa9dfe5b45d39ba3ff0375f7bccb316a0a3bc1eff742c352f
+  data.tar.gz: e647e80d96b215e825ed0fba41b0f38e8418df1e9f56189c11b2b0847b6868f403efbc1583b4b8c6e4fa633b66841c08cc684da0ef242f9489c590cbcc6c2907

data/bin/bettys

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+
+require "bettys"
+
+opts = Optimist.options do
+  opt :level, "Starting level (1-15)", type: :int, default: 1, short: "n"
+  opt :mode, "Game mode", type: :string, default: "marathon"
+end
+
+%w[marathon sprint ultra infinite].include?(opts[:mode]).or do
+  err "Invalid mode: %s. Valid: marathon, sprint, ultra, infinite", opts[:mode]
+end
+
+opts[:level].between?(1, 15).or do
+  err "Level must be between 1 and 15, got: %d", opts[:level]
+end
+
+COLOR_PAIR = {}
+game = nil
+game_over = false
+
+begin
+  Curses.init_screen
+  Curses.start_color
+  Curses.use_default_colors
+
+  COLOR.each_with_index do |(piece, color), i|
+    Curses.init_pair(i + 1, Curses.const_get("COLOR_#{color}"), Curses::COLOR_BLACK)
+    COLOR_PAIR[piece] = i + 1
+  end
+
+  Curses.raw
+  Curses.stdscr.keypad(true)
+  Curses.noecho
+  Curses.timeout = 20
+  Curses.curs_set(0)
+
+  game = Bettys.new(opts[:mode].to_sym, opts[:level])
+  game.imprint
+  game.start
+
+  loop do
+    game.draw
+    Curses.refresh
+
+    if game.over?
+      game.stop
+      game_over = true
+      break
+    end
+
+    case Curses.getch
+    when ?h, Curses::Key::LEFT
+      game.sync do
+        game.piece.move!(-1)
+          .tif { game.notify_lock_reset }
+      end
+    when ?l, Curses::Key::RIGHT
+      game.sync do
+        game.piece.move!(+1)
+          .tif { game.notify_lock_reset }
+      end
+    when ?k
+      game.sync do
+        game.piece.rotate!(clockwise: true)
+          .tif { game.notify_lock_reset }
+      end
+    when ?K
+      game.sync do
+        game.piece.rotate!(clockwise: false)
+          .tif { game.notify_lock_reset }
+      end
+    when ?j, Curses::Key::DOWN
+      game.soft_drop
+    when ?J
+      game.drop
+    when ?H
+      game.dash(-1)
+    when ?L
+      game.dash(+1)
+    when ?c
+      game.hold
+    when " "
+      game.toggle
+    when ?q, 3
+      if game.paused
+        break
+      else
+        game.toggle
+      end
+    when Curses::KEY_RESIZE
+      Curses.clear
+      game.imprint
+    end
+  end
+ensure
+  game&.stop
+  Curses.close_screen
+
+  game.show_game_over if game_over && game
+end

data/lib/bettys.rb

@@ -0,0 +1,9 @@
+require "curses"
+require "optimist"
+require "emanlib"
+
+require_relative "consts"
+require_relative "purse"
+require_relative "board"
+require_relative "pieces"
+require_relative "game"

data/lib/board.rb

@@ -0,0 +1,52 @@
+Action = Enum[{ Single: 1 }, :Double, :Triple, :Bettys]
+
+class Board
+  attr_reader :matrix
+
+  SCORE = {
+    Action.Single => 100,
+    Action.Double => 300,
+    Action.Triple => 500,
+    Action.Bettys => 800,
+  }.freeze
+
+  def initialize
+    # Each row must be a separate array instance
+    @matrix = Array.new(40) { Array.new(10) }
+  end
+
+  # Check if a point is valid (in bounds and empty)
+  def valid?(point)
+    point.x.between?(0, 9) &&
+      point.y.between?(0, 39) &&
+      @matrix[point.y][point.x].nil?
+  end
+
+  # Lock a piece into the matrix
+  def absorb(piece)
+    piece.niños.each do |niño|
+      @matrix[niño.y][niño.x] = COLOR_PAIR[piece.shape]
+    end
+  end
+
+  # Clear completed lines, return [score, count]
+  def simplify
+    cleared = []
+
+    # Check visible rows (below skyline)
+    ((SKYLINE_INDEX + 1)...40).each do |y|
+      cleared << y if @matrix[y].all?
+    end
+
+    # Remove cleared rows and add empty rows at top
+    cleared.each do |y|
+      @matrix.delete_at(y)
+      @matrix.unshift(Array.new(10))
+
+      # Adjust remaining indices since we modified the array
+      cleared.map! { |i| i >= y ? i : i }
+    end
+
+    [SCORE[cleared.size] || 0, cleared.size]
+  end
+end

data/lib/consts.rb

@@ -0,0 +1,92 @@
+SKYLINE_INDEX = 19
+
+MINIMUM = let **{
+  HEIGHT: 24,
+  WIDTH: 58,
+}
+
+COLOR = {
+  I: :CYAN,
+  J: :BLUE,
+  L: :YELLOW,
+  O: :YELLOW,
+  S: :GREEN,
+  T: :MAGENTA,
+  Z: :RED,
+}
+
+module Box
+  def self.[](art)
+    art = art.chars
+    let **{
+      h: art[1], v: art[4],
+      top: { left: art[0], right: art[2] },
+      bottom: { left: art[3], right: art[5] },
+    }
+  end
+
+  NORMAL = Box["┌─┐└│┘"]
+  THICK = Box["┏━┓┗┃┛"]
+  DOTTED = Box["┌┄┐└┆┘"]
+  DOUBLE = Box["╔═╗╚║╝"]
+end
+
+GAME_OVER_ART = <<~ART.chomp.freeze
+  ⠀⠀⠀⢀⣾⣦⣤⣤⣤⡀⣀⣤⣄⣀⣀⡄⠀⠀⠀⠀
+  ⠀⣆⣴⣿⣿⣿⣿⣿⢏⣾⣿⣿⣿⣿⣿⣿⣤⡀⡀⠀
+  ⠀⣼⡿⠛⠿⠍⠛⠟⠾⠛⢛⣿⠻⢿⣿⣿⣿⣿⡟⠀
+  ⢠⡟⠋⢀⠌⠀⠀⠀⠀⠀⠒⢄⠀⠲⠟⣿⣿⣿⡇⠀
+  ⠀⠘⡁⢊⣆⣄⡀⠀⠀⠀⠀⠈⠢⠀⠰⣼⣿⣿⠷⠃
+  ⠀⢲⡟⣹⠀⢻⡆⠀⠀⢠⣂⢉⠆⢀⢀⣼⡿⠋⠀⠀
+  ⠀⢿⣇⠀⠙⠉⠀⡄⠀⠈⠉⠉⠁⠘⣿⣿⡧⠀⠀⠀
+  ⠀⠀⢤⡭⠶⢒⡠⢶⡦⠒⠤⣀⣀⠴⠫⣂⠇⠀⠀⠀
+  ⠀⠀⠻⠱⣒⣲⢉⠜⠁⠀⠀⠀⢳⣄⠀⠀⠀⠀⠀⠀
+  ⠀⠀⠀⠀⡇⠸⠃⠀⡠⠒⠀⠀⠀⡏⠳⡀⠀⠀⠀⠀
+  ⠀⠀⠀⠀⡇⠀⣠⣾⣷⣄⠀⠀⠀⢰⠀⡸⠀⠀⠀⠀
+  ⠀⠀⠀⠀⠈⠉⠸⣿⣿⣿⣗⢤⡀⢸⣴⠃⠀⠀⠀⠀
+  ⠀⠀⠀⠀⠀⠀⠀⠀⠈⠛⠛⠃⠛⠛⠃⠀⠀⠀
+ART
+
+GAME_OVER_MESSAGES = [
+  "Thanks for playing honey",
+  "See you again sweetie!",
+  "You did great darling!",
+  "Come back soon love!",
+  "That was beautiful babe!",
+  "You're a star, gorgeous!",
+  "Until next time cutie!",
+  "What a ride sweetheart!",
+  "You played your heart out!",
+  "Rest up, you earned it!",
+  "Until next time, sugar",
+  "Sweet dreams, beautiful",
+  "Come back soon, cutie",
+  "You're a star, sweetheart",
+  "Miss you already, babe",
+  "That was fun, gorgeous",
+  "You're amazing, love",
+  "Lovely playing with you",
+  "You light up my screen",
+  "Be back soon, angel",
+
+].freeze
+
+def err(message, *args)
+  $stderr.printf "Error: #{message}\n", *args
+  exit 1
+end
+
+def origin
+  [
+    (Curses.lines - MINIMUM.HEIGHT) / 2,
+    (Curses.cols - MINIMUM.WIDTH) / 2,
+  ]
+end
+
+def typewriter(text, delay: 0.04)
+  text.each_char do |c|
+    print c
+    $stdout.flush
+    sleep delay
+  end
+end

data/lib/game.rb

@@ -0,0 +1,355 @@
+class Curses::Window
+  def print(s, point = nil, color = nil)
+    setpos(point.y, point.x) if point
+
+    if color
+      attron(Curses.color_pair(color))
+      addstr(s)
+      attroff(Curses.color_pair(color))
+    else
+      addstr(s)
+    end
+  end
+
+  def draw_box(y, x, width, height, art = Box::NORMAL)
+    setpos(y, x)
+    addstr(art.top.left + art.h * (width - 2) + art.top.right)
+
+    (1...height - 1).each do |row|
+      setpos(y + row, x)
+      addstr(art.v)
+      setpos(y + row, x + width - 1)
+      addstr(art.v)
+    end
+
+    setpos(y + height - 1, x)
+    addstr(art.bottom.left + art.h * (width - 2) + art.bottom.right)
+  end
+
+  def clear_area(y, x, width, height)
+    blank = " " * width
+    height.times do |row|
+      setpos(y + row, x)
+      addstr(blank)
+    end
+  end
+end
+
+LOCK_DELAY = 0.5
+MAX_LOCK_RESETS = 15
+
+class Bettys
+  attr_reader :piece
+  attr_accessor :paused, :score
+
+  def initialize(mode, level = 1)
+    @mode = mode
+    @board = Board.new
+    @purse = Purse.new(@board)
+
+    @piece = @purse.pick
+    @hold = nil
+    @can_hold = true
+
+    @score = 0
+    @time = mode == :ultra ? 120 : 0
+    @line = 0
+    @start_level = level
+    @level = level
+
+    @mutex = Mutex.new
+    @paused = false
+    @running = false
+
+    @lock_timer = nil
+    @lock_resets = 0
+    @grounded = false
+  end
+
+  def start
+    return if @running
+
+    @running = true
+
+    @gravity_thread = Thread.new do
+      while @running
+        sleep speed
+        next if @paused || over?
+
+        sync do
+          if @piece.slide!
+            @grounded = false
+            @score += 1
+          else
+            start_lock_timer
+          end
+        end
+      end
+    end
+
+    @lock_thread = Thread.new do
+      while @running
+        sleep 0.05
+        next if @paused || over?
+
+        sync do
+          if @lock_timer && Time.now >= @lock_timer
+            lock_piece
+          end
+        end
+      end
+    end
+
+    @timer_thread = Thread.new do
+      while @running
+        sleep 1
+        next if @paused || over?
+
+        @time += @mode == :ultra ? -1 : 1
+      end
+    end
+  end
+
+  def stop
+    @running = false
+    [@gravity_thread, @lock_thread, @timer_thread].each do |t|
+      t&.join(1)
+    end
+  end
+
+  def toggle
+    @paused = !@paused
+  end
+
+  def sync
+    @mutex.synchronize { yield if block_given? }
+  end
+
+  def over?
+    @piece.nil? || !@piece.valid? ||
+      case @mode
+      when :marathon then @line >= 150
+      when :sprint   then @line >= 40
+      when :ultra    then @time <= 0
+      when :infinite then false
+      end
+  end
+
+  def drop
+    count = 0
+    sync do
+      count += 1 while @piece.slide!
+      lock_piece
+    end
+    @score += 2 * count
+  end
+
+  def soft_drop
+    sync do
+      @piece.slide!.tif { @score += 1 }
+    end
+  end
+
+  def dash(direction)
+    sync do
+      nil while @piece.move!(direction)
+      notify_lock_reset
+    end
+  end
+
+  def hold
+    sync do
+      return unless @can_hold
+
+      @hold, @piece = @piece, @hold || @purse.pick
+
+      @hold.orientation = Face.↑
+      @hold.center = Point[20, 4]
+
+      @can_hold = false
+      reset_lock_state
+    end
+  end
+
+  def notify_lock_reset
+    return unless @grounded
+
+    if @lock_resets < MAX_LOCK_RESETS
+      @lock_timer = Time.now + LOCK_DELAY
+      @lock_resets += 1
+    end
+  end
+
+  def imprint
+    oy, ox = origin
+    win = Curses.stdscr
+
+    win.print("HOLD", Point[oy, ox + 6])
+    win.draw_box(oy + 1, ox + 2, 14, 6, Box::DOTTED)
+
+    win.print("SCORE", Point[oy + 8, ox + 3])
+    win.print("TIME",  Point[oy + 11, ox + 3])
+    win.print("LINE",  Point[oy + 14, ox + 3])
+    win.print("LEVEL", Point[oy + 17, ox + 3])
+
+    win.draw_box(oy + 1, ox + 18, 22, 22, Box::DOUBLE)
+
+    win.print("NEXT", Point[oy, ox + 46])
+    win.draw_box(oy + 1, ox + 42, 14, 18, Box::NORMAL)
+  end
+
+  def draw
+    oy, ox = origin
+    win = Curses.stdscr
+
+    draw_hold(oy, ox, win)
+    draw_stats(oy, ox, win)
+    draw_matrix(oy, ox, win)
+    draw_active_piece(oy, ox, win)
+    draw_next(oy, ox, win)
+    draw_pause_overlay(oy, ox, win) if @paused
+  end
+
+  # Called AFTER Curses.close_screen — prints to normal stdout
+  def show_game_over
+    puts
+    puts GAME_OVER_ART
+    puts
+
+    sleep 0.3
+
+    typewriter "  Score: #{@score}"
+    puts
+    typewriter "  Lines: #{@line}"
+    puts
+    typewriter "  Level: #{@level}"
+    puts
+    typewriter "  Time:  #{format_time(@time)}"
+    puts
+    puts
+
+    sleep 0.5
+
+    message = GAME_OVER_MESSAGES.sample
+    typewriter "  #{message} "
+
+    sleep 0.4
+    print "💋"
+    $stdout.flush
+
+    puts
+    puts
+  end
+
+  def speed
+    base = 0.8 - ((@level - 1) * 0.007)
+    base ** (@level - 1)
+  end
+
+  private
+
+  def start_lock_timer
+    unless @grounded
+      @grounded = true
+      @lock_timer = Time.now + LOCK_DELAY
+      @lock_resets = 0
+    end
+  end
+
+  def reset_lock_state
+    @grounded = false
+    @lock_timer = nil
+    @lock_resets = 0
+  end
+
+  def lock_piece
+    @board.absorb(@piece)
+    score, count = @board.simplify
+
+    @score += score * @level
+    @line += count
+    @level = [@start_level + (@line / 10), 15].min
+
+    @piece = @purse.pick
+    @can_hold = true
+    reset_lock_state
+  end
+
+  def draw_hold(oy, ox, win)
+    win.clear_area(oy + 2, ox + 3, 12, 4)
+    @hold&.display(oy + 3, ox + 6)
+  end
+
+  def draw_stats(oy, ox, win)
+    win.print(@score.to_s.rjust(12), Point[oy + 9, ox + 3])
+    win.print(format_time(@time).rjust(12), Point[oy + 12, ox + 3])
+    win.print(@line.to_s.rjust(12), Point[oy + 15, ox + 3])
+    win.print(@level.to_s.rjust(12), Point[oy + 18, ox + 3])
+  end
+
+  def format_time(seconds)
+    minutes = seconds.abs / 60
+    secs = seconds.abs % 60
+    "%d:%02d" % [minutes, secs]
+  end
+
+  def draw_matrix(oy, ox, win)
+    (SKYLINE_INDEX + 1...40).each do |row|
+      screen_y = oy + 1 + row - SKYLINE_INDEX
+
+      10.times do |col|
+        screen_x = ox + 19 + col * 2
+        cell = @board.matrix[row][col]
+
+        win.setpos(screen_y, screen_x)
+
+        if cell
+          win.attron(Curses.color_pair(cell))
+          win.addstr("██")
+          win.attroff(Curses.color_pair(cell))
+        else
+          win.addstr("  ")
+        end
+      end
+    end
+  end
+
+  def draw_active_piece(oy, ox, win)
+    sync do
+      return unless @piece
+
+      color = COLOR_PAIR[@piece.shape]
+
+      @piece.ghost.each do |niño|
+        next if niño.y <= SKYLINE_INDEX
+
+        win.setpos(oy + 1 + niño.y - SKYLINE_INDEX, ox + 19 + niño.x * 2)
+        win.attron(Curses.color_pair(color))
+        win.addstr("░░")
+        win.attroff(Curses.color_pair(color))
+      end
+
+      @piece.niños.each do |niño|
+        next if niño.y <= SKYLINE_INDEX
+
+        win.setpos(oy + 1 + niño.y - SKYLINE_INDEX, ox + 19 + niño.x * 2)
+        win.attron(Curses.color_pair(color))
+        win.addstr("██")
+        win.attroff(Curses.color_pair(color))
+      end
+    end
+  end
+
+  def draw_next(oy, ox, win)
+    win.clear_area(oy + 2, ox + 43, 12, 16)
+
+    @purse.bag.last(5).reverse_each.with_index do |piece, i|
+      piece.display(oy + 3 + i * 3, ox + 46)
+    end
+  end
+
+  def draw_pause_overlay(oy, ox, win)
+    win.setpos(oy + 11, ox + 24)
+    win.addstr("  PAUSED  ")
+  end
+end

data/lib/pieces.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+PIECES = %i[I J L O S T Z].freeze
+
+Face = Enum[:↑, :→, :↓, :←]
+
+BLUEPRINT = {
+  I: [
+    [[0, 0], [0, -1], [0, 1], [0, 2]],
+    [[0, 0], [-1, 0], [1, 0], [2, 0]],
+    [[0, 0], [0, -1], [0, -2], [0, 1]],
+    [[0, 0], [-1, 0], [-2, 0], [1, 0]],
+  ],
+  J: [
+    [[0, 0], [0, -1], [-1, -1], [0, 1]],
+    [[0, 0], [-1, 0], [-1, 1], [1, 0]],
+    [[0, 0], [0, 1], [1, 1], [0, -1]],
+    [[0, 0], [1, 0], [1, -1], [-1, 0]],
+  ],
+  L: [
+    [[0, 0], [0, -1], [-1, 1], [0, 1]],
+    [[0, 0], [-1, 0], [1, 0], [1, 1]],
+    [[0, 0], [0, -1], [0, 1], [1, -1]],
+    [[0, 0], [-1, 0], [-1, -1], [1, 0]],
+  ],
+  O: [
+    [[0, 0], [-1, 1], [-1, 0], [0, 1]],
+    [[0, 0], [0, 1], [1, 0], [1, 1]],
+    [[0, 0], [0, -1], [1, -1], [1, 0]],
+    [[0, 0], [-1, 0], [0, -1], [-1, -1]],
+  ],
+  S: [
+    [[0, 0], [-1, 1], [0, -1], [-1, 0]],
+    [[0, 0], [-1, 0], [0, 1], [1, 1]],
+    [[0, 0], [0, 1], [1, -1], [1, 0]],
+    [[0, 0], [0, -1], [-1, -1], [1, 0]],
+  ],
+  T: [
+    [[0, 0], [0, -1], [-1, 0], [0, 1]],
+    [[0, 0], [-1, 0], [0, 1], [1, 0]],
+    [[0, 0], [0, -1], [0, 1], [1, 0]],
+    [[0, 0], [0, -1], [-1, 0], [1, 0]],
+  ],
+  Z: [
+    [[0, 0], [-1, 0], [-1, -1], [0, 1]],
+    [[0, 0], [-1, 1], [0, 1], [1, 0]],
+    [[0, 0], [0, -1], [1, 0], [1, 1]],
+    [[0, 0], [0, -1], [-1, 0], [1, -1]],
+  ],
+}.freeze
+
+OFFSET = {
+  JLSTZ: {
+    [Face.↑, Face.→] => [[0, 0], [0, -1], [1, -1], [-2, 0], [-2, -1]],
+    [Face.→, Face.↑] => [[0, 0], [0, 1], [-1, 1], [2, 0], [2, 1]],
+    [Face.→, Face.↓] => [[0, 0], [0, 1], [-1, 1], [2, 0], [2, 1]],
+    [Face.↓, Face.→] => [[0, 0], [0, -1], [1, -1], [-2, 0], [-2, -1]],
+    [Face.↓, Face.←] => [[0, 0], [0, 1], [1, 1], [-2, 0], [-2, 1]],
+    [Face.←, Face.↓] => [[0, 0], [0, -1], [-1, -1], [2, 0], [2, -1]],
+    [Face.←, Face.↑] => [[0, 0], [0, -1], [-1, -1], [2, 0], [2, -1]],
+    [Face.↑, Face.←] => [[0, 0], [0, 1], [1, 1], [-2, 0], [-2, 1]],
+  },
+  I: {
+    [Face.↑, Face.→] => [[0, 0], [0, -2], [0, 1], [-1, -2], [2, 1]],
+    [Face.→, Face.↑] => [[0, 0], [0, 2], [0, -1], [1, 2], [-2, -1]],
+    [Face.→, Face.↓] => [[0, 0], [0, -1], [0, 2], [2, -1], [-1, 2]],
+    [Face.↓, Face.→] => [[0, 0], [0, 1], [0, -2], [-2, 1], [1, -2]],
+    [Face.↓, Face.←] => [[0, 0], [0, 2], [0, -1], [1, 2], [-2, -1]],
+    [Face.←, Face.↓] => [[0, 0], [0, -2], [0, 1], [-1, -2], [2, 1]],
+    [Face.←, Face.↑] => [[0, 0], [0, 1], [0, -2], [-2, 1], [1, -2]],
+    [Face.↑, Face.←] => [[0, 0], [0, -1], [0, 2], [2, -1], [-1, 2]],
+  },
+}.freeze
+
+Point = Struct.new(:y, :x) do
+  def +(other)
+    Point[y + other.y, x + other.x]
+  end
+
+  def -(other = nil)
+    return Point[-y, -x] if other.nil?
+    Point[y - other.y, x - other.x]
+  end
+end
+
+class Array
+  def to_p
+    Point[self[0], self[1]]
+  end
+end
+
+# A tetrimino piece
+class BettyNiño
+  attr_reader :shape
+  attr_accessor :orientation, :center
+
+  def initialize(board, shape)
+    @board = board
+    @shape = shape
+    @orientation = Face.↑
+    @center = Point[20, 4]
+  end
+
+  # Move horizontally. Returns truthy if successful.
+  def move!(delta = -1)
+    niños.all? { |niño| @board.valid?(niño + Point[0, delta]) }
+      .tif { @center = @center + Point[0, delta] }
+  end
+
+  # Move down one row. Returns truthy if successful.
+  def slide!
+    niños.all? { |niño| @board.valid?(niño + Point[1, 0]) }
+      .tif { @center = @center + Point[1, 0] }
+  end
+
+  # Check if current position is valid
+  def valid?
+    niños.all? { |niño| @board.valid?(niño) }
+  end
+
+  # Rotate using Super Rotation System
+  def rotate!(clockwise: true)
+    current = @orientation
+    target = (current + (clockwise ? 1 : -1)) % 4
+
+    offsets = OFFSET[@shape == :I ? :I : :JLSTZ]
+    target_niños = niños(target)
+
+    offsets[[current, target]].any? do |offset|
+      offset_point = offset.to_p
+      target_niños.all? { |niño| @board.valid?(niño + offset_point) }
+        .tif do
+          @center = @center + offset_point
+          @orientation = target
+        end
+    end
+  end
+
+  # Get cell positions for given orientation
+  def niños(orientation = @orientation)
+    BLUEPRINT[@shape][orientation].map { |dy, dx| @center + Point[dy, dx] }
+  end
+
+  # Find ghost (landing preview) position
+  def ghost
+    original = @center
+    @center = Point[@center.y, @center.x]
+
+    @center = @center + Point[1, 0] while can_drop?
+
+    niños
+  ensure
+    @center = original
+  end
+
+  # Draw piece at its current position on the game board
+  def draw(oy, ox, win)
+    color = COLOR_PAIR[@shape]
+
+    niños.each do |niño|
+      next if niño.y <= SKYLINE_INDEX
+
+      win.setpos(oy + 1 + niño.y - SKYLINE_INDEX, ox + 19 + niño.x * 2)
+      win.attron(Curses.color_pair(color))
+      win.addstr("██")
+      win.attroff(Curses.color_pair(color))
+    end
+  end
+
+  # Draw piece in a preview box (hold/next)
+  def display(y, x)
+    color = COLOR_PAIR[@shape]
+    win = Curses.stdscr
+
+    win.attron(Curses.color_pair(color))
+
+    BLUEPRINT[@shape][Face.↑].each do |dy, dx|
+      win.setpos(y + 1 + dy, x + dx * 2)
+      win.addstr("██")
+    end
+
+    win.attroff(Curses.color_pair(color))
+  end
+
+  private
+
+  def can_drop?
+    niños.all? { |niño| @board.valid?(niño + Point[1, 0]) }
+  end
+end
+
+# O-piece doesn't rotate
+class BettyNiñoO < BettyNiño
+  def rotate!(*)
+    # No-op for O piece
+  end
+end
+
+# Generate subclasses for each piece type
+PIECES.each do |shape|
+  class_name = "BettyNiño#{shape}"
+  next if Object.const_defined?(class_name) # Skip O, already defined
+
+  klass = Class.new(BettyNiño) do
+    define_method(:initialize) do |board|
+      super(board, shape)
+    end
+  end
+
+  Object.const_set(class_name, klass)
+end
+
+# Special case: O needs its own initialize
+class BettyNiñoO
+  def initialize(board)
+    super(board, :O)
+  end
+end

data/lib/purse.rb

@@ -0,0 +1,33 @@
+class Purse
+  attr_reader :bag
+
+  def initialize(board)
+    @board = board
+    @bag = []
+    @seen = Set.new
+    fill(7)
+  end
+
+  def pick
+    @bag.pop.tap { fill }
+  end
+
+  private
+
+  def get
+    @seen.clear if @seen.size == 7
+    piece = BettyNiño.subclasses.sample
+
+    if @seen.include?(piece)
+      get
+    else
+      @seen.add(piece)
+      piece.new(@board)
+    end
+  end
+
+  def fill(n = 1)
+    n.times { @bag << get }
+  end
+end
+

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: bettys
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- emanrdesu
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: curses
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: optimist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: emanlib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Bettys is a terminal-based Tetris clone written in Ruby with ncurses,
+  featuring four game modes (marathon, sprint, ultra, infinite), vim-style controls,
+  hold piece, ghost piece, SRS rotation, and more.
+email:
+- janitor@waifu.club
+executables:
+- bettys
+extensions: []
+extra_rdoc_files: []
+files:
+- asset/game.png
+- asset/over.png
+- bin/bettys
+- lib/bettys.rb
+- lib/board.rb
+- lib/consts.rb
+- lib/game.rb
+- lib/pieces.rb
+- lib/purse.rb
+homepage: https://github.com/emanrdesu/bettys
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A terminal-based Tetris clone
+test_files: []