gemtris 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3ddbaa519dfd59a7069c33f8bf7f41ddf8f0e55e0f299bbc69ce14c359d0cd37
+  data.tar.gz: ffcb28edc3c99de861aa2d84429bbd35308a0dc34b76be4cd598f2cf040c477e
+SHA512:
+  metadata.gz: 0e9a7db66141fab4057e0e17df027ef21a4ed54d65e79d8aaf813a35ab87f7c6bdee3c6c93add1158a44c576fbfacdeec96bd19300dc829d16873f59874b99b8
+  data.tar.gz: 1ce2aa2f38e817cbfb2ea557347e904975a938949a98a0cc5d1c2c99cfea28b094b5458f0b3c203a0182eab6d8c869c9d93f123f3129ef741e0d66428d65cc74

data/bin/gemtris

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'gemtris'
+
+GemtrisGame.new.play

data/lib/gemtris/cell.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: false
+
+# Encapsulates the logic of a single square on the coordinate grid.
+class Cell
+  CELL_VISUAL_SIZE = 3
+  EMPTY_CELL_VISUAL = '-'.freeze
+  FILLED_CELL_VISUAL = '[ ]'.freeze
+  CENTER_CELL_VISUAL = '[+]'.freeze
+  SHADOW_CELL_VISUAL = '( )'.freeze
+  SOLID_CELL_VISUAL = '[=]'.freeze
+
+  attr_reader :solid
+
+  def initialize
+    clear
+  end
+
+  def to_s
+    visual.center CELL_VISUAL_SIZE
+  end
+
+  def clear
+    self.solid = false
+    self.visual = EMPTY_CELL_VISUAL
+  end
+
+  def shape_fill
+    self.visual = FILLED_CELL_VISUAL
+  end
+
+  def shape_center_fill
+    self.visual = CENTER_CELL_VISUAL
+  end
+
+  def shade
+    self.visual = SHADOW_CELL_VISUAL
+  end
+
+  def solidify
+    self.solid = true
+    self.visual = SOLID_CELL_VISUAL
+  end
+
+  def solid?
+    @solid
+  end
+
+  private
+
+  attr_writer :solid
+
+  attr_accessor :visual
+end

data/lib/gemtris/grid.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: false
+
+require_relative 'cell'
+
+# Simulates the coordinate grid.
+class Grid
+  GRID_BORDER_VERT = '||'.freeze
+  GRID_BORDER_HORIZ = '='.freeze
+  GRID_DEFAULT_WIDTH = 10
+  GRID_DEFAULT_HEIGHT = 20
+
+  attr_reader :height, :width, :board_visual_width
+
+  def initialize(width = GRID_DEFAULT_WIDTH, height = GRID_DEFAULT_HEIGHT)
+    @board_visual_width = (width * Cell::CELL_VISUAL_SIZE) +
+                          (GRID_BORDER_VERT.size * 2)
+    @width = width
+    @height = height
+    @coordinate = init_coordinate
+  end
+
+  def to_s
+    vertical_visual = grid_vertical_visual
+    "#{vertical_visual}\n#{grid_playable_visual}\n#{vertical_visual}"
+  end
+
+  def draw_shape(shape)
+    draw_shadow(shape)
+
+    shape.filled_coords.each do |coord|
+      cell = find_cell(coord)
+      cell&.shape_fill
+    end
+
+    draw_shape_center(shape)
+  end
+
+  def draw_shadow(shape)
+    projected_landing_coords(shape).each do |shadow_coord|
+      cell = find_cell(shadow_coord)
+      cell&.shade
+    end
+  end
+
+  def draw_shape_center(shape)
+    center_coordinates = shape.absolute_center_coord
+    return unless center_coordinates
+
+    cell = find_cell(center_coordinates)
+    cell&.shape_center_fill
+  end
+
+  def undraw_shape(shape)
+    clear_coords = shape.filled_coords | projected_landing_coords(shape)
+    clear_coords.each do |coord|
+      cell = find_cell(coord)
+      cell&.clear
+    end
+  end
+
+  def solidify_shape(shape)
+    shape.filled_coords.each do |coord|
+      cell = find_cell(coord)
+      cell&.solidify
+    end
+  end
+
+  def row_full?(row_y_value)
+    row = coordinate[row_y_value]
+    row.values.all?(&:solid?)
+  end
+
+  def clear_row!(row_y_value)
+    row = coordinate[row_y_value]
+    row.each_value(&:clear)
+  end
+
+  def deep_clear_row!(row_y_value)
+    coordinate[row_y_value] = init_row_columns
+  end
+
+  def move_row_from_to(row_number, move_to)
+    coordinate[move_to] = coordinate[row_number]
+    coordinate[row_number] = init_row_columns
+  end
+
+  def shape_move_x?(shape, direction_sign = 1)
+    shape.filled_coords.none? do |adjacent_coord|
+      adjacent_coord[:x] += 1 * direction_sign
+      coord_out_bounds?(adjacent_coord) || !!find_cell(adjacent_coord)&.solid?
+    end
+  end
+
+  def shape_invalid_position?(shape)
+    shape_out_bounds?(shape) || shape_touching_solid?(shape)
+  end
+
+  def shape_touching_solid?(shape)
+    shape.filled_coords.any? { |coord| coord_touching_solid?(coord) }
+  end
+
+  def shape_out_bounds?(shape)
+    shape.filled_coords.any? { |coord| coord_out_bounds?(coord) }
+  end
+
+  def coord_touching_solid?(coord)
+    return true if coord_touching_bottom?(coord)
+    return true if find_cell(coord)&.solid?
+
+    coord_under = coord.dup
+    coord_under[:y] += 1
+
+    cell = find_cell(coord_under)
+    !!cell&.solid?
+  end
+
+  def coord_touching_bottom?(coord)
+    coord[:y] == height
+  end
+
+  def coord_out_bounds?(coord)
+    coord[:y] <= 0 || coord[:y] > height ||
+      coord[:x] <= 0 || coord[:x] > width
+  end
+
+  def [](row_y_value)
+    coordinate[row_y_value]
+  end
+
+  def []=(row_y_value, new_row)
+    coordinate[row_y_value] = new_row
+  end
+
+  private
+
+  def projected_landing_coords(shape)
+    original_position = shape.position.dup
+    shape.position[:y] += 1 until shape_invalid_position?(shape)
+
+    landing_coords = shape.filled_coords
+    shape.position = original_position
+    landing_coords
+  end
+
+  def find_cell(coord)
+    return nil if coord_out_bounds?(coord)
+
+    coordinate[coord[:y]][coord[:x]]
+  end
+
+  def grid_vertical_visual
+    GRID_BORDER_HORIZ * board_visual_width
+  end
+
+  def grid_playable_visual
+    coordinate.values.map do |row|
+      "#{GRID_BORDER_VERT}#{row.values.join}#{GRID_BORDER_VERT}"
+    end.join "\n"
+  end
+
+  def init_coordinate
+    coordinate = {}
+    (1..height).each do |y|
+      coordinate[y] = init_row_columns
+    end
+    coordinate
+  end
+
+  def init_row_columns
+    (1..width).to_h { |x_pos| [x_pos, Cell.new] }
+  end
+
+  attr_reader :coordinate
+end

data/lib/gemtris/player.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: false
+
+require_relative 'utils'
+
+# Used to encapsulate player logic.
+class Player
+  INVALID_ACTION = 'That is not a valid action!'.freeze
+
+  FALL_ACTION = :fall
+  MOVE_LEFT_ACTION = :move_left
+  MOVE_RIGHT_ACTION = :move_right
+  ROTATE_CLOCKWISE_ACTION = :rotate_clockwise
+  ROTATE_COUNTER_ACTION = :rotate_counter_clockwise
+  FREEFALL_ACTION = :freefall
+
+  PLAY_AGAIN_CHOICE = 'yes'.freeze
+
+  INPUTS_FOR_ACTIONS = {
+    ['<', ','] => MOVE_LEFT_ACTION,
+    ['>', '.'] => MOVE_RIGHT_ACTION,
+    ['d'] => ROTATE_COUNTER_ACTION,
+    ['a'] => ROTATE_CLOCKWISE_ACTION,
+    ['s'] => FREEFALL_ACTION
+  }.freeze
+
+  ACTION_PROMPT = format(
+    GemtrisText[:tetromino_control_prompt],
+    *INPUTS_FOR_ACTIONS.keys.flatten
+  )
+
+  def prompt_tetromino_action
+    puts ACTION_PROMPT
+    CLI.divide_screen
+
+    loop do
+      action = find_action(CLI.user_input)
+      return action if action
+
+      CLI.error(INVALID_ACTION)
+    end
+  end
+
+  def play_again?
+    answer = CLI.prompt GemtrisText[:play_again]
+    answered_yes?(answer)
+  end
+
+  private
+
+  def answered_yes?(answer)
+    PLAY_AGAIN_CHOICE.start_with?(answer) ||
+      answer.start_with?(PLAY_AGAIN_CHOICE)
+  end
+
+  def find_action(player_input)
+    return FALL_ACTION if player_input.empty?
+
+    INPUTS_FOR_ACTIONS.each_key do |input_list|
+      return INPUTS_FOR_ACTIONS[input_list] if input_list.include? player_input
+    end
+
+    nil
+  end
+end

data/lib/gemtris/shapes.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: false
+
+# I don't remember if grid is needed.
+# This file might only need cell.rb
+require_relative 'grid'
+
+# An interface for general shape-related functionality.
+module GemtrisShapes
+  ROTATE_CENTER = :rotate_center
+  LIMB_DATA = :limb_data
+
+  FILLED_CELL_PATTERN = 'N'.freeze
+  EMPTY_CELL_PATTERN = ' '.freeze
+
+  # Golomb names taken from
+  # "https://quuxplusone.github.io/blog/2025/04/19/tetromino-names/"
+  #
+  # :rotate_center is the coordinates of the
+  # limb that the shape rotates around. if this is not provided
+  # it is assumed that the shape cannot rotate
+
+  SHAPES =
+    [
+      # Square tetromino
+      { LIMB_DATA => "NN\nNN" },
+
+      # T-tetromino
+      { LIMB_DATA => " N\nNNN", ROTATE_CENTER => { y: 1, x: 1 } },
+
+      # Straight tetromino
+      { LIMB_DATA => 'NNNN', ROTATE_CENTER => { y: 0, x: 0 } },
+
+      # Skrew tetromino green
+      { LIMB_DATA => " NN\nNN", ROTATE_CENTER => { y: 1, x: 1 } },
+
+      # Skrew tetromino red
+      { LIMB_DATA => "NN\n NN", ROTATE_CENTER => { y: 1, x: 1 } },
+
+      # L-tetromino blue
+      { LIMB_DATA => "N\nNNN", ROTATE_CENTER => { y: 1, x: 0 } },
+
+      # L-tetromino orange
+      { LIMB_DATA => "  N\nNNN", ROTATE_CENTER => { y: 1, x: 2 } }
+    ].freeze
+
+  def self.all_shapes
+    SHAPES.map { |shape_data| Shape.new(shape_data) }
+  end
+
+  def self.random_shape
+    Shape.new(SHAPES.sample)
+  end
+end
+
+# This is used to simulate physical shapes in the game in conjunction with the Grid class.
+class Shape
+  FILLED_CELL_PATTERN = GemtrisShapes::FILLED_CELL_PATTERN
+  EMPTY_CELL_PATTERN = GemtrisShapes::EMPTY_CELL_PATTERN
+  EMPTY_SPACE_VISUAL = ' ' * Cell::FILLED_CELL_VISUAL.size
+
+  CLOCKWISE_SIGN = 1
+  COUNTER_CLOCKWISE_SIGN = -1
+
+  VISUAL_REGEX = /#{FILLED_CELL_PATTERN}|#{EMPTY_CELL_PATTERN}/
+  VISUAL_HASH = {
+    FILLED_CELL_PATTERN => Cell::FILLED_CELL_VISUAL,
+    EMPTY_CELL_PATTERN => EMPTY_SPACE_VISUAL
+  }.freeze
+
+  DEFAULT_POSITION = { y: 1, x: 1 }.freeze
+
+  attr_reader :visual, :limbs, :center_limb
+  attr_accessor :position
+
+  def initialize(shape_data)
+    limb_data = shape_data[GemtrisShapes::LIMB_DATA]
+
+    @visual = create_visual(limb_data)
+    @limbs = translate_string_to_limbs(limb_data)
+    @position = DEFAULT_POSITION.dup
+    @center_limb = find_center_limb shape_data[GemtrisShapes::ROTATE_CENTER]
+  end
+
+  def filled_coords
+    limbs.map { |limb| limb_absolute_coord(limb) }
+  end
+
+  def filled_x_coords
+    filled_coords.each_with_object(Set.new) { |coord, set| set << coord[:x] }
+  end
+
+  def rotate(rotation_direction = CLOCKWISE_SIGN)
+    return unless can_rotate?
+
+    offset_position_by_rotation(rotation_direction)
+    limbs.each { |limb| rotate_limb!(limb, rotation_direction) }
+  end
+
+  def absolute_center_coord
+    return nil unless can_rotate?
+
+    limb_absolute_coord(center_limb)
+  end
+
+  alias to_s visual
+
+  private
+
+  def can_rotate?
+    !!center_limb
+  end
+
+  def offset_position_by_rotation(rotation_direction = CLOCKWISE_SIGN)
+    rotated_center = limb_rotated(center_limb, rotation_direction)
+
+    position[:x] -= rotated_center[:x] - center_limb[:x]
+    position[:y] -= rotated_center[:y] - center_limb[:y]
+  end
+
+  def rotate_limb!(limb, rotation_direction = CLOCKWISE_SIGN)
+    rotated_coord = limb_rotated(limb, rotation_direction)
+    limb.merge!(rotated_coord)
+  end
+
+  def limb_rotated(limb, rotation_direction = CLOCKWISE_SIGN)
+    { y: limb[:x] * -rotation_direction, x: limb[:y] * rotation_direction }
+  end
+
+  def limb_absolute_coord(limb)
+    {
+      y: position[:y] + limb[:y],
+      x: position[:x] + limb[:x]
+    }
+  end
+
+  def create_visual(shape_string)
+    shape_string.gsub(VISUAL_REGEX, VISUAL_HASH)
+  end
+
+  def find_center_limb(rotation_limb)
+    limbs.find { |limb| limb == rotation_limb }
+  end
+
+  def translate_string_to_limbs(shape_string)
+    data = []
+    shape_string.split(/$/).each_with_index do |row, y_coord|
+      clean_row = row.delete "\n"
+      data.concat row_shape_x_coords(y_coord, clean_row)
+    end
+
+    data
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  def row_shape_x_coords(y_coord, row_shape_string)
+    current_coord = 0
+    last_matched_index = 0
+    row_coords = []
+    (0...row_shape_string.size).each do |substr_index|
+      pattern = row_shape_string[last_matched_index..substr_index]
+      next unless [EMPTY_CELL_PATTERN, FILLED_CELL_PATTERN].include? pattern
+
+      row_coords << { y: y_coord, x: current_coord } if cell_pattern?(pattern)
+      current_coord += 1
+      last_matched_index = substr_index.next
+    end
+    row_coords
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  def cell_pattern?(pattern)
+    pattern == FILLED_CELL_PATTERN
+  end
+end

data/lib/gemtris/utils.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: false
+
+require 'psych'
+
+# Comand-Line Utilities
+module CLI
+  DEFAULT_PROMPT = 'Please enter text:'.freeze
+  DEFAULT_ERROR = 'Unknown error!'.freeze
+  SCREEN_DIVIDER = "\n------------------------\n\n".freeze
+
+  def self.divide_screen
+    print SCREEN_DIVIDER
+  end
+
+  def self.clear_screen
+    system('clear') || system('cls') || divide_screen
+  end
+
+  def self.user_input
+    print '> '
+    gets.chomp.strip.downcase
+  end
+
+  def self.prompt(message = DEFAULT_PROMPT)
+    puts message
+    divide_screen
+    user_input
+  end
+
+  def self.error(message = DEFAULT_ERROR)
+    divide_screen
+    puts "[ERROR]: #{message}"
+    divide_screen
+  end
+end
+
+# Provides an interface for developers to access the related YAML texts.
+module GemtrisText
+  # assuming yml/gemtris and we're in lib/gemtris/
+  TEXTS = Psych.load_file("#{__dir__}/../../yml/gemtris.yml") # Psych.load(IO.read("#{__dir__}/../../yml/gemtris.yml"))
+
+  def self.[](key)
+    TEXTS[key.to_s]
+  end
+end

data/lib/gemtris.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: false
+
+# Load all dependencies.
+Dir["#{__dir__}/gemtris/*.rb"].each { |path| require path }
+
+# The orchestator of gameplay.
+class GemtrisGame
+  TITLE_PLATE = '] GEMTRIS ['.freeze
+  TITLE_DECOR = '-'.freeze
+
+  TUTORIAL_ANSWER = 'tutorial'.freeze
+  START_ANSWER = 'start'.freeze
+  INVALID_CHOICE = 'Invalid answer!'.freeze
+
+  ACTION_TIME_STEP = :step
+  ACTION_DONT_STEP = :dont_step
+  ACTION_KILL_TETROMINO = :kill
+
+  FAIL_TETROMINO_SPAWN = :failed_spawn
+  SUCESSFUL_TETROMINO_SPAWN = :spawned_tetromino
+
+  TIME_AFTER_ACTION = 0.1
+  CELL_FALL_TIME = 0.025
+  TETROMINO_FREEFALL_WAIT = 0.025
+  TETROMINO_DEATH_WAIT = 0.3
+
+  LEFT_DIRECTION = -1
+  RIGHT_DIRECTION = 1
+
+  AFTER_TUTORIAL_TEXT = GemtrisText[:after_tutorial] % START_ANSWER
+
+  LOSE_TEXT = GemtrisText[:lose]
+
+  TUTORIAL_TEXT = format(
+    GemtrisText[:tutorial],
+    Cell::EMPTY_CELL_VISUAL,
+    Cell::FILLED_CELL_VISUAL,
+    Cell::CENTER_CELL_VISUAL,
+    Cell::SHADOW_CELL_VISUAL,
+    Cell::SOLID_CELL_VISUAL
+  )
+
+  WELCOME_TEXT = format(
+    GemtrisText[:welcome],
+    TUTORIAL_ANSWER,
+    START_ANSWER
+  )
+
+  def play
+    intro_sequence
+    game_loop
+  end
+
+  private
+
+  attr_reader :grid, :player
+  attr_accessor :shape, :desired_spawn_x
+
+  def reset_game
+    @grid = Grid.new
+    @shape = nil
+    @player = Player.new
+    @desired_spawn_x = grid.width / 2
+  end
+
+  def game_loop
+    loop do
+      game_sequence
+      break unless player.play_again?
+    end
+  end
+
+  def intro_sequence
+    CLI.clear_screen
+    start_or_tutorial
+  end
+
+  def start_or_tutorial
+    puts WELCOME_TEXT
+    CLI.divide_screen
+
+    loop do
+      answer = CLI.user_input
+
+      tutorial_answer_loop if answer == TUTORIAL_ANSWER
+      break if [TUTORIAL_ANSWER, START_ANSWER].include? answer
+
+      CLI.error INVALID_CHOICE
+    end
+  end
+
+  def tutorial_answer_loop
+    CLI.clear_screen
+    puts TUTORIAL_TEXT
+    CLI.divide_screen
+    loop do
+      answer = CLI.prompt(AFTER_TUTORIAL_TEXT)
+      break if answer == START_ANSWER
+
+      CLI.error INVALID_CHOICE
+    end
+  end
+
+  def game_sequence
+    CLI.clear_screen
+    reset_game
+    gemtris_match_loop
+    display_match_loss
+  end
+
+  def gemtris_match_loop
+    loop do
+      spawn_result = spawn_fitting_tetromino
+      break if spawn_result == FAIL_TETROMINO_SPAWN
+
+      tetromino_control_loop
+      tetromino_die
+      clear_full_rows
+    end
+
+    tetromino_die
+    display_grid
+  end
+
+  def spawn_fitting_tetromino
+    randomized_shapes = GemtrisShapes.all_shapes.shuffle!
+
+    randomized_shapes.each do |random_shape|
+      self.shape = random_shape
+      spawn_result = set_shape_spawn
+
+      return spawn_result if spawn_result == SUCESSFUL_TETROMINO_SPAWN
+    end
+
+    FAIL_TETROMINO_SPAWN
+  end
+
+  def set_shape_spawn
+    desired_spawns.each do |x_pos|
+      shape.position[:x] = x_pos
+
+      return SUCESSFUL_TETROMINO_SPAWN unless grid.shape_invalid_position?(shape)
+    end
+
+    shape.position[:x] = desired_spawns.first
+    FAIL_TETROMINO_SPAWN
+  end
+
+  def desired_spawns
+    sort_distance_to_desired = proc { |x_pos| (desired_spawn_x - x_pos).abs }
+    (1..grid.width).to_a.shuffle.sort_by(&sort_distance_to_desired)
+  end
+
+  def tetromino_control_loop
+    loop do
+      draw_shape_and_display_grid
+
+      sleep TIME_AFTER_ACTION
+      action_result = player_action_loop
+
+      break if action_result == ACTION_KILL_TETROMINO
+
+      tetromino_fall_step
+
+      break if tetromino_stop_control?
+    end
+  end
+
+  def tetromino_stop_control?
+    grid.shape_touching_solid? shape
+  end
+
+  def tetromino_die
+    grid.solidify_shape shape
+    display_grid
+    self.desired_spawn_x = shape.position[:x]
+    sleep TETROMINO_DEATH_WAIT
+  end
+
+  def tetromino_fall_step
+    draw_shape_and_display_grid
+    sleep TIME_AFTER_ACTION
+    tetromino_descend
+  end
+
+  def player_action_loop
+    loop do
+      player_action = player.prompt_tetromino_action
+      action_result = perform_player_action(player_action)
+
+      break action_result unless action_result == ACTION_DONT_STEP
+
+      draw_shape_and_display_grid
+    end
+  end
+
+  def perform_player_action(player_action)
+    case player_action
+    when Player::FALL_ACTION then ACTION_TIME_STEP
+    when Player::MOVE_LEFT_ACTION then tetromino_move_left
+    when Player::MOVE_RIGHT_ACTION then tetromino_move_right
+    when Player::FREEFALL_ACTION then tetromino_freefall
+    when Player::ROTATE_CLOCKWISE_ACTION
+      rotate_tetromino Shape::CLOCKWISE_SIGN
+    when Player::ROTATE_COUNTER_ACTION
+      rotate_tetromino Shape::COUNTER_CLOCKWISE_SIGN
+    end
+  end
+
+  def tetromino_move_left
+    tetromino_move_x LEFT_DIRECTION
+  end
+
+  def tetromino_move_right
+    tetromino_move_x RIGHT_DIRECTION
+  end
+
+  def tetromino_move_x(direction_sign = RIGHT_DIRECTION)
+    return ACTION_DONT_STEP unless grid.shape_move_x?(shape, direction_sign)
+
+    shape.position[:x] += 1 * direction_sign
+    ACTION_KILL_TETROMINO if tetromino_stop_control?
+  end
+
+  def tetromino_descend
+    shape.position[:y] += 1
+  end
+
+  def rotate_tetromino(rotation_sign = Shape::CLOCKWISE_SIGN)
+    shape.rotate(rotation_sign)
+    shape.rotate(-rotation_sign) if grid.shape_invalid_position?(shape)
+
+    ACTION_DONT_STEP
+  end
+
+  def tetromino_freefall
+    until tetromino_stop_control?
+      tetromino_descend
+      draw_shape_and_display_grid
+      sleep TETROMINO_FREEFALL_WAIT
+    end
+    ACTION_KILL_TETROMINO
+  end
+
+  def clear_full_rows
+    lowest_empty_row = nil
+    (1..grid.height).reverse_each do |row_number|
+      if grid.row_full?(row_number)
+        clear_row!(row_number)
+        lowest_empty_row ||= row_number
+      elsif lowest_empty_row
+        row_fall_to!(row_number, lowest_empty_row)
+        lowest_empty_row -= 1
+      end
+    end
+  end
+
+  def row_fall_to!(from_row, to_row)
+    row = grid[from_row]
+    return if no_solid_cells_in_row?(row)
+
+    empty_row = grid[to_row]
+
+    (1..grid.width).each do |x_pos|
+      next unless row[x_pos].solid?
+
+      empty_row[x_pos] = row[x_pos]
+      row[x_pos] = Cell.new
+      display_grid
+      sleep CELL_FALL_TIME
+    end
+  end
+
+  def clear_row!(row_y)
+    (1..grid.width).each do |x_pos|
+      cell = grid[row_y][x_pos]
+      next unless cell.solid?
+
+      cell.clear
+      display_grid
+      sleep CELL_FALL_TIME
+    end
+  end
+
+  def no_solid_cells_in_row?(row)
+    row.values.none?(&:solid?)
+  end
+
+  def display_match_loss
+    puts LOSE_TEXT
+    CLI.divide_screen
+  end
+
+  def display_grid
+    grid_visual_size = grid.board_visual_width
+    centered_title = TITLE_PLATE.center(grid_visual_size, TITLE_DECOR)
+
+    CLI.clear_screen
+    puts "#{centered_title}\n\n"
+    puts grid
+    puts "\n#{TITLE_DECOR * grid_visual_size}"
+    puts
+  end
+
+  def draw_shape_and_display_grid
+    grid.draw_shape(shape)
+    display_grid
+    grid.undraw_shape(shape)
+  end
+end

data/yml/gemtris.yml

@@ -0,0 +1,61 @@
+welcome: |
+  WELCOME to [TETRIS]!
+
+  If you'd like a rundown on how to play please type, (%s).
+  Otherwise, type (%s)!
+
+lose: |
+  OH NO!
+
+  You LOST! That was a great game!
+
+tutorial: |
+  BASICS:
+
+    Tetris is a game played on a grid of squares or "cells".
+
+    Your goal is play for as long as you can, guiding the block shapes ("tetrominos"),
+    as they descend from the top of the grid.
+
+    A tetromino will solidify when it touches the bottom of the grid or another solid cell.
+    When this occurs, a new tetromino will appear for you to control.
+
+  CONTROLS:
+
+    Tetrominos can be moved left or right, and rotated in 90 degree increments.
+
+    You will have time to think between actions. The tetromino only falls one cell
+    after an action is performed.
+
+    Rotating does not cause the tetromino to fall. This is a safe action.
+
+    A tetromino "shadow" will appear that shows you where the tetromino is going to fall.
+
+  LOSE/WIN:
+
+    You lose when a tetromino has no more space to fall and touches the top of the grid.
+
+    Connecting an entire row of solid cells will cause the row is disintegrate. The solid rows
+    above will collapse to fill the space. This is your key to success!
+
+  An empty cell looks like this: %s
+  A tetromino limb looks like this: %s
+  The center of a tetromino looks like this: %s
+  A tetromino shadow looks like this: %s
+  A solid cell looks like this: %s
+
+
+after_tutorial: |
+  To start, please type (%s)!
+
+tetromino_control_prompt: |
+  To Move Left:           %s or %s
+  To Move Right:          %s or %s
+  To Rotate Clockwise:         %s
+  To Rotate Counter-Clockwise: %s
+  To Freefall:                 %s
+  
+  Or input nothing to fall once.
+
+play_again: |
+  Would you like to play another game? (yes or .)

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: gemtris
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- TacoMilitary
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-10-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Using the keys on your keyboard, manipulate a falling shape within a
+  grid of cells in turn-based gameplay. Try to play for as long as possible without
+  touching the top of the grid.
+email: tacobuddy18@outlook.com
+executables:
+- gemtris
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/gemtris
+- lib/gemtris.rb
+- lib/gemtris/cell.rb
+- lib/gemtris/grid.rb
+- lib/gemtris/player.rb
+- lib/gemtris/shapes.rb
+- lib/gemtris/utils.rb
+- yml/gemtris.yml
+homepage: https://github.com/TacoMilitary/gemtris
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.1
+signing_key:
+specification_version: 4
+summary: This is a simple command-line Ruby recreation of the game Tetris!
+test_files: []