boardgame_engine 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e57f58857092b8b08b48de9bafcf09a08297302fcbe695afde86125615d07f1
-  data.tar.gz: c7de6b02681a7b7def284e31186fc61281fe9ae41dfe75464dc0a5e83b5bde9a
+  metadata.gz: 7129074317f7ea44e65ad18e5952e2401e47be99186e26dd42b0c083ebc91797
+  data.tar.gz: f87aebcb6502cbfd9d8ee04e60b775f1497e09527863f3f820a1edb202297330
 SHA512:
-  metadata.gz: 2155a5ca5a0c871e277a7a0e4beb9ea25b86a17ada30481d4f37b6104385c300095ef61cd694b860cadc72ab9230f6f7d199934a15c96de3278b22756174b07c
-  data.tar.gz: accc0b89071a919f466be01d1ecd68bc4f2fe3096817ff6340b161e731beabe1e05142399af352922cf7ac521ee95711fc6681068cf5b083c3e7ba9fb51ca02f
+  metadata.gz: 1c1ab01918757d936b1ee97cf8d75bbf19a300e71450b0c1896fcd9cdda0f804b25324b71ef01929d8d231f96ef7af15ec023690dc52d5a738e8b363da43c4f8
+  data.tar.gz: b10198cde214fe10e7a861a27419e6235b25a84ef1fac0992de66e0297668da8e3f600effaae0049c12a5343e761dccfb623594bc2621d40b24063e8b8d82cb0

data/lib/boardgame_engine/boardgame.rb

@@ -3,142 +3,144 @@
 # All classes in this script are intended to be abstract, meaning they should
 # not be called on their own.
 
-# Class representing a physical board comprised of a grid in a board game. It
-# acts as both the View and Model if the project were to be compared to a MVC
-# model. It plays both roles as the board in a board game not only stores data,
-# but also IS the data that must be shown to the players.
-class Board
-  attr_reader :board
-
-  def initialize(row, col)
-    @board = Array.new(row) { Array.new(col) { nil } }
-  end
-
-  def display(show_row: false, show_col: false)
-    if show_row
-      @board.each_with_index { |row, idx| puts("#{idx} " + format_row(row)) }
-    else
-      @board.each { |row| puts format_row(row) }
+module BoardgameEngine
+  # Class representing a physical board comprised of a grid in a board game. It
+  # acts as both the View and Model if the project were to be compared to a MVC
+  # model. It plays both roles as the board in a board game not only stores data,
+  # but also IS the data that must be shown to the players.
+  class Board
+    attr_reader :board
+
+    def initialize(row, col)
+      @board = Array.new(row) { Array.new(col) { nil } }
     end
-    return unless show_col
 
-    column_spacer = show_row ? "  " : ""
-    puts(@board[0].each_index.reduce(column_spacer) do |str, idx|
-      str + " #{idx} "
-    end)
-  end
+    def display(show_row: false, show_col: false)
+      if show_row
+        @board.each_with_index { |row, idx| puts("#{idx} " + format_row(row)) }
+      else
+        @board.each { |row| puts format_row(row) }
+      end
+      return unless show_col
+
+      column_spacer = show_row ? "  " : ""
+      puts(@board[0].each_index.reduce(column_spacer) do |str, idx|
+        str + " #{idx} "
+      end)
+    end
 
-  def move_piece(start_row, start_col, end_row, end_col)
-    piece = @board[start_row][start_col]
-    @board[start_row][start_col] = nil
-    destination = @board[end_row][end_col]
-    @board[end_row][end_col] = piece
+    def move_piece(start_row, start_col, end_row, end_col)
+      piece = @board[start_row][start_col]
+      @board[start_row][start_col] = nil
+      destination = @board[end_row][end_col]
+      @board[end_row][end_col] = piece
 
-    destination
-  end
+      destination
+    end
 
-  private
+    private
 
-  def format_row(row)
-    row.map { |elem| "[#{elem.nil? ? " " : elem}]" }.join
-  end
+    def format_row(row)
+      row.map { |elem| "[#{elem.nil? ? " " : elem}]" }.join
+    end
 
-  def spot_playable?(piece, row, col)
-    piece.possible_moves.include? [row, col]
+    def spot_playable?(piece, row, col)
+      piece.possible_moves.include? [row, col]
+    end
   end
-end
 
-# Class representing a player in a game
-class Player
-  attr_reader :name
+  # Class representing a player in a game
+  class Player
+    attr_reader :name
 
-  def initialize(name)
-    @name = name
-  end
+    def initialize(name)
+      @name = name
+    end
 
-  def to_s
-    @name.to_s
+    def to_s
+      @name.to_s
+    end
   end
-end
 
-# Class for running a board game.
-class Boardgame
-  EXIT_INSTRUCTIONS ||= "Try a sample input or input 'back' to leave the " \
-  "tutorial. Type in 'exit' anytime to exit the game fully"
-
-  def initialize(board, instructions, name1 = "Player 1", name2 = "Player 2")
-    @player1 = Player.new(name1)
-    @player2 = Player.new(name2)
-    @board = setup_board(board)
-    @instructions = instructions
-    @winner = nil
-  end
+  # Class for running a board game.
+  class Boardgame
+    EXIT_INSTRUCTIONS ||= "Try a sample input or input 'back' to leave the " \
+    "tutorial. Type in 'exit' anytime to exit the game fully"
+
+    def initialize(board, instructions, name1 = "Player 1", name2 = "Player 2")
+      @player1 = Player.new(name1)
+      @player2 = Player.new(name2)
+      @board = setup_board(board)
+      @instructions = instructions
+      @winner = nil
+    end
 
-  def self.play(do_onboarding: true)
-    puts "What is Player 1's name?"
-    player1 = gets.chomp
-    puts "What is Player 2's name?"
-    player2 = gets.chomp
-    @game = new(player1, player2)
-
-    puts "Welcome to #{@game}!"
-    @game.onboarding if do_onboarding
-    puts "Starting #{@game}..."
-    @game.start
-  end
+    def self.play(do_onboarding: true)
+      puts "What is Player 1's name?"
+      player1 = gets.chomp
+      puts "What is Player 2's name?"
+      player2 = gets.chomp
+      @game = new(player1, player2)
+
+      puts "Welcome to #{@game}!"
+      @game.onboarding if do_onboarding
+      puts "Starting #{@game}..."
+      @game.start
+    end
 
-  def to_s(game_name = "boardgame")
-    "#{game_name} between #{@player1} and #{@player2}"
-  end
+    def to_s(game_name = "boardgame")
+      "#{game_name} between #{@player1} and #{@player2}"
+    end
 
-  def onboarding
-    puts "Would you like a tutorial on how to play on this program? \n(y, n)"
-    case gets.chomp
-    when "y"
-      tutorial
-    when "n"
-      puts "Skipping tutorial"
-    else
-      puts 'Please answer either "y" or "n"'
-      onboarding
+    def onboarding
+      puts "Would you like a tutorial on how to play on this program? \n(y, n)"
+      case gets.chomp
+      when "y"
+        tutorial
+      when "n"
+        puts "Skipping tutorial"
+      else
+        puts 'Please answer either "y" or "n"'
+        onboarding
+      end
     end
-  end
 
-  def tutorial
-    puts @instructions + Boardgame::EXIT_INSTRUCTIONS
-    input = gets.chomp
-    until input == "back"
-      exit if input == "exit"
-      puts valid_input?(input) ? "Valid input!" : "Invalid input"
+    def tutorial
+      puts @instructions + Boardgame::EXIT_INSTRUCTIONS
       input = gets.chomp
+      until input == "back"
+        exit if input == "exit"
+        puts valid_input?(input) ? "Valid input!" : "Invalid input"
+        input = gets.chomp
+      end
     end
-  end
 
-  def start(turn = @player1)
-    @turn = turn
-    @board.display
-    until @winner
-      play_turn
+    def start(turn = @player1)
+      @turn = turn
       @board.display
+      until @winner
+        play_turn
+        @board.display
+      end
+      puts "#{@winner} wins!"
     end
-    puts "#{@winner} wins!"
-  end
 
-  protected
+    protected
 
-  def proper_format_input(special_commands = [])
-    input = gets.chomp
-    until valid_input?(input)
-      exit if input == "exit"
-      return input if special_commands.include?(input)
-
-      puts "Input is in the wrong format or out of bounds. Try again"
+    def proper_format_input(special_commands = [])
       input = gets.chomp
+      until valid_input?(input)
+        exit if input == "exit"
+        return input if special_commands.include?(input)
+
+        puts "Input is in the wrong format or out of bounds. Try again"
+        input = gets.chomp
+      end
+      input
     end
-    input
-  end
 
-  def setup_board(board)
-    board.new
+    def setup_board(board)
+      board.new
+    end
   end
 end

data/lib/boardgame_engine/chess.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require_relative "boardgame"
+require_relative "multiplayergame"
+
+module SampleChess
+  class ChessBoard < BoardgameEngine::Board
+    attr_reader :board
+
+    def initialize(player1, player2)
+      super(8, 8)
+      setup(player1, player2)
+    end
+
+    def display
+      super(show_row: true, show_col: true)
+    end
+
+    private
+
+    def setup(player1, player2)
+      set_pawns(player1, player2)
+      set_non_pawns(player1, player2)
+    end
+
+    def set_pawns(player1, player2)
+      @board[1] = @board[1].map { Pawn.new(player1, 1) }
+      @board[-2] = @board[-2].map { Pawn.new(player2, -1) }
+    end
+
+    def set_non_pawns(player1, player2)
+      pieces = [Rook, Knight, Bishop, Queen, King, Bishop, Knight, Rook]
+      pieces.each_with_index do |piece, idx|
+        @board[0][idx] = piece.new(player1)
+        @board[7][7 - idx] = piece.new(player2)
+      end
+    end
+  end
+
+  class Chess < BoardgameEngine::Boardgame
+    include TwoPlayers
+
+    def initialize(name1 = "Player 1", name2 = "Player 2")
+      @instructions = "You can select spots on the board by inputting the row " \
+      "and column with a comma in between. See example below\n1, 1\n"
+      super(ChessBoard, @instructions, name1, name2)
+    end
+
+    def to_s
+      super("chess")
+    end
+
+    private
+
+    def valid_input?(input)
+      coords = input.split(",")
+      coords.all? { |c| c.match?(/[[:digit:]]/) && c.to_i.between?(0, 7) }
+    end
+
+    def valid_piece?(piece)
+      !piece.nil? && piece.owner == @turn
+    end
+
+    def select_piece
+      input = proper_format_input
+      input.split(",").map(&:to_i) => [row, col]
+      if valid_piece? @board.board.dig(row, col)
+        [row, col]
+      else
+        puts "Invalid piece. Try again"
+        select_piece
+      end
+    end
+
+    def select_destination(piece, row, col)
+      input = proper_format_input(["back"])
+      return "back" if input == "back"
+
+      input.split(",").map(&:to_i) => [end_row, end_col]
+      if piece.valid_move?(row, col, end_row, end_col, @board.board)
+        [end_row, end_col]
+      else
+        puts "Invalid destination. Try again"
+        select_destination(piece, row, col)
+      end
+    end
+
+    def play_turn
+      puts "#{@turn}'s turn\nSelect your piece"
+      select_piece => [row, col]
+      piece = @board.board[row][col]
+      puts "Select where to move #{piece} to. Type back to reselect piece"
+      dest = select_destination(piece, row, col)
+      return if dest == "back"
+
+      killed = @board.move_piece(row, col, dest[0], dest[1])
+      @winner = piece.owner if killed.is_a?(King)
+      change_turn
+    end
+
+    def setup_board(board)
+      board.new(@player1, @player2)
+    end
+  end
+
+  class ChessPiece
+    attr_accessor :status
+    attr_reader :owner
+
+    def initialize(owner, name)
+      @kill_log = []
+      @status = "alive"
+      @owner = owner
+      @name = name
+    end
+
+    def kill(other)
+      @kill_log.push(other)
+      other.status = "dead"
+    end
+
+    def to_s
+      @name.to_s
+    end
+
+    protected
+
+    def valid_diag_move?(row, col, end_row, end_col, board)
+      ((end_row - row).abs == (end_col - col).abs) \
+      && clear_path?(row, col, end_row, end_col, board)
+    end
+
+    def valid_horz_move?(row, col, end_row, end_col, board)
+      (end_row == row) && clear_path?(row, col, end_row, end_col, board)
+    end
+
+    def valid_vert_move?(row, col, end_row, end_col, board)
+      (end_col == col) && clear_path?(row, col, end_row, end_col, board)
+    end
+
+    private
+
+    def next_cell(row, col, end_row, end_col)
+      row_move = 0
+      col_move = 0
+
+      col_move = (end_col - col) / (end_col - col).abs if end_col != col
+      row_move = (end_row - row) / (end_row - row).abs if end_row != row
+
+      [row + row_move, col + col_move]
+    end
+
+    def clear_path?(row, col, end_row, end_col, board)
+      current_tile = board.dig(row, col)
+      if (row == end_row) && (col == end_col)
+        current_tile.nil? || (current_tile.owner != @owner)
+      elsif current_tile.nil? || current_tile.equal?(self)
+        next_cell(row, col, end_row, end_col) => [next_row, next_col]
+        clear_path?(next_row, next_col, end_row, end_col, board)
+      else
+        false
+      end
+    end
+  end
+
+  class Pawn < ChessPiece
+    def initialize(owner, front)
+      super(owner, "p")
+      @first_move = true
+      @front = front
+    end
+
+    def valid_move?(row, col, end_row, end_col, board)
+      return false unless valid_forward_move?(row, end_row)
+
+      if col == end_col # only forward
+        valid_dest = board.dig(end_row, end_col).nil?
+        @first_move = false if valid_dest
+        return valid_dest
+      elsif (col - end_col).abs == 1 # diagonal movement
+        other_piece = board.dig(end_row, end_col)
+        return other_piece && (other_piece.owner != @owner)
+      end
+      false
+    end
+
+    private
+
+    def valid_forward_move?(row, end_row)
+      if @first_move
+        (row + @front * 2 == end_row) || (row + @front == end_row)
+      else
+        row + @front == end_row
+      end
+    end
+  end
+
+  class Queen < ChessPiece
+    def initialize(owner)
+      super(owner, "Q")
+    end
+
+    def valid_move?(row, col, end_row, end_col, board)
+      valid_diag_move?(row, col, end_row, end_col, board) \
+      || valid_horz_move?(row, col, end_row, end_col, board) \
+      || valid_vert_move?(row, col, end_row, end_col, board)
+    end
+  end
+
+  class Rook < ChessPiece
+    def initialize(owner)
+      super(owner, "R")
+    end
+
+    def valid_move?(row, col, end_row, end_col, board)
+      valid_horz_move?(row, col, end_row, end_col, board) \
+      || valid_vert_move?(row, col, end_row, end_col, board)
+    end
+  end
+
+  class Bishop < ChessPiece
+    def initialize(owner)
+      super(owner, "B")
+    end
+
+    def valid_move?(row, col, end_row, end_col, board)
+      valid_diag_move?(row, col, end_row, end_col, board)
+    end
+  end
+
+  class King < ChessPiece
+    def initialize(owner)
+      super(owner, "K")
+    end
+
+    def valid_move?(row, col, end_row, end_col, board)
+      return false unless (row - end_row).abs == 1 && (col - end_col).abs == 1
+
+      valid_diag_move?(row, col, end_row, end_col, board) \
+      || valid_horz_move?(row, col, end_row, end_col, board) \
+      || valid_vert_move?(row, col, end_row, end_col, board)
+    end
+  end
+
+  class Knight < ChessPiece
+    def initialize(owner)
+      # K was already taken by king, so I had to choose N
+      super(owner, "N")
+    end
+
+    def valid_move?(row, col, end_row, end_col, board)
+      within_movement(row, col, end_row, end_col) \
+      && not_occupied(end_row, end_col, board)
+    end
+
+    private
+
+    def within_movement(row, col, end_row, end_col)
+      ((row - end_row).abs == 2 and (col - end_col).abs == 1) \
+      || ((row - end_row).abs == 1 and (col - end_col).abs == 2)
+    end
+
+    def not_occupied(end_row, end_col, board)
+      spot = board.dig(end_row, end_col)
+      spot.nil? || spot.owner != @owner
+    end
+  end
+end

data/lib/boardgame_engine/connect4.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "boardgame"
+require_relative "multiplayergame"
+
+module SampleConnect4
+  class Connect4Board < BoardgameEngine::Board
+    def initialize
+      super(6, 7)
+    end
+
+    def display
+      super(show_col: true)
+    end
+
+    def drop_chip(col, owner)
+      @board.reverse_each do |row|
+        if row[col].nil?
+          row[col] = owner
+          break
+        end
+      end
+    end
+  end
+
+  class Connect4 < BoardgameEngine::Boardgame
+    include TwoPlayers
+
+    @instructions = "You can select which column to drop you chip into by" \
+    " typing in the row number."
+
+    def initialize(name1 = "Player 1", name2 = "Player 2")
+      super(Connect4Board, @instructions, name1, name2)
+    end
+
+    def to_s
+      super("connect-four")
+    end
+
+    private
+
+    def valid_input?(input)
+      input.match?(/[[:digit:]]/) && input.to_i.between?(0, 6)
+    end
+
+    def play_turn
+      puts "#{@turn}'s turn. Choose a column to drop your chip in"
+      col = proper_format_input.to_i
+      @board.drop_chip(col, @turn)
+      @winner = @turn if win?
+      change_turn
+    end
+
+    def win?
+      [@board.board,
+      @board.board.transpose,
+      align_diagonally(@board.board),
+      align_diagonally(@board.board.transpose)].each do |config|
+        config.each { |direction| return true if four_in_a_row? direction }
+      end
+      false
+    end
+
+    def four_in_a_row?(row)
+      counts = row.chunk { |x| x }.map { |x, xs| [x, xs.length] }
+      return true if counts.any? { |x, count| count > 3 && !x.nil? }
+    end
+
+    def align_diagonally(board)
+      board.map.with_index do |row, idx|
+        left_filler = Array.new(board.length - 1 - idx, nil)
+        right_filler = Array.new(idx, nil)
+        left_filler + row + right_filler
+      end
+    end
+  end
+end

data/lib/boardgame_engine/sample_games.rb

@@ -0,0 +1,5 @@
+require_relative "chess"
+require_relative "connect4"
+
+module SampleGames
+end

data/lib/boardgame_engine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BoardgameEngine
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/boardgame_engine.rb

@@ -2,10 +2,9 @@
 
 require_relative "boardgame_engine/version"
 
-require_relative "boardgame_engine/boardgame"
-require_relative "boardgame_engine/multiplayergame"
-require_relative "boardgame_engine/chess/chess"
-require_relative "boardgame_engine/connect4/connect4"
+require "boardgame_engine/boardgame"
+require "boardgame_engine/multiplayergame"
+require "boardgame_engine/sample_games"
 
 module BoardgameEngine
   class Error < StandardError; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: boardgame_engine
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - FortHoney
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-05 00:00:00.000000000 Z
+date: 2022-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -40,10 +40,10 @@ files:
 - boardgame_engine.gemspec
 - lib/boardgame_engine.rb
 - lib/boardgame_engine/boardgame.rb
-- lib/boardgame_engine/chess/chess.rb
-- lib/boardgame_engine/chess/chess_pieces.rb
-- lib/boardgame_engine/connect4/connect4.rb
+- lib/boardgame_engine/chess.rb
+- lib/boardgame_engine/connect4.rb
 - lib/boardgame_engine/multiplayergame.rb
+- lib/boardgame_engine/sample_games.rb
 - lib/boardgame_engine/version.rb
 - sig/boardgame_engine.rbs
 homepage: https://github.com/Forthoney/boardgame_engine

data/lib/boardgame_engine/chess/chess.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require "./lib/boardgame_engine"
-require "./lib/boardgame_engine/chess/chess_pieces"
-
-class ChessBoard < Board
-  attr_reader :board
-
-  def initialize(player1, player2)
-    super(8, 8)
-    setup(player1, player2)
-  end
-
-  def display
-    super(show_row: true, show_col: true)
-  end
-
-  private
-
-  def setup(player1, player2)
-    set_pawns(player1, player2)
-    set_non_pawns(player1, player2)
-  end
-
-  def set_pawns(player1, player2)
-    @board[1] = @board[1].map { Pawn.new(player1, 1) }
-    @board[-2] = @board[-2].map { Pawn.new(player2, -1) }
-  end
-
-  def set_non_pawns(player1, player2)
-    pieces = [Rook, Knight, Bishop, Queen, King, Bishop, Knight, Rook]
-    pieces.each_with_index do |piece, idx|
-      @board[0][idx] = piece.new(player1)
-      @board[7][7 - idx] = piece.new(player2)
-    end
-  end
-end
-
-class Chess < Boardgame
-  include TwoPlayers
-
-  def initialize(name1 = "Player 1", name2 = "Player 2")
-    @instructions = "You can select spots on the board by inputting the row " \
-    "and column with a comma in between. See example below\n1, 1\n"
-    super(ChessBoard, @instructions, name1, name2)
-  end
-
-  def to_s
-    super("chess")
-  end
-
-  private
-
-  def valid_input?(input)
-    coords = input.split(",")
-    coords.all? { |c| c.match?(/[[:digit:]]/) && c.to_i.between?(0, 7) }
-  end
-
-  def valid_piece?(piece)
-    !piece.nil? && piece.owner == @turn
-  end
-
-  def select_piece
-    input = proper_format_input
-    input.split(",").map(&:to_i) => [row, col]
-    if valid_piece? @board.board.dig(row, col)
-      [row, col]
-    else
-      puts "Invalid piece. Try again"
-      select_piece
-    end
-  end
-
-  def select_destination(piece, row, col)
-    input = proper_format_input(["back"])
-    return "back" if input == "back"
-
-    input.split(",").map(&:to_i) => [end_row, end_col]
-    if piece.valid_move?(row, col, end_row, end_col, @board.board)
-      [end_row, end_col]
-    else
-      puts "Invalid destination. Try again"
-      select_destination(piece, row, col)
-    end
-  end
-
-  def play_turn
-    puts "#{@turn}'s turn\nSelect your piece"
-    select_piece => [row, col]
-    piece = @board.board[row][col]
-    puts "Select where to move #{piece} to. Type back to reselect piece"
-    dest = select_destination(piece, row, col)
-    return if dest == "back"
-
-    killed = @board.move_piece(row, col, dest[0], dest[1])
-    @winner = piece.owner if killed.is_a?(King)
-    change_turn
-  end
-
-  def setup_board(board)
-    board.new(@player1, @player2)
-  end
-end

data/lib/boardgame_engine/chess/chess_pieces.rb

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-class ChessPiece
-  attr_accessor :status
-  attr_reader :owner
-
-  def initialize(owner, name)
-    @kill_log = []
-    @status = "alive"
-    @owner = owner
-    @name = name
-  end
-
-  def kill(other)
-    @kill_log.push(other)
-    other.status = "dead"
-  end
-
-  def to_s
-    @name.to_s
-  end
-
-  protected
-
-  def valid_diag_move?(row, col, end_row, end_col, board)
-    ((end_row - row).abs == (end_col - col).abs) \
-    && clear_path?(row, col, end_row, end_col, board)
-  end
-
-  def valid_horz_move?(row, col, end_row, end_col, board)
-    (end_row == row) && clear_path?(row, col, end_row, end_col, board)
-  end
-
-  def valid_vert_move?(row, col, end_row, end_col, board)
-    (end_col == col) && clear_path?(row, col, end_row, end_col, board)
-  end
-
-  private
-
-  def next_cell(row, col, end_row, end_col)
-    row_move = 0
-    col_move = 0
-
-    col_move = (end_col - col) / (end_col - col).abs if end_col != col
-    row_move = (end_row - row) / (end_row - row).abs if end_row != row
-
-    [row + row_move, col + col_move]
-  end
-
-  def clear_path?(row, col, end_row, end_col, board)
-    current_tile = board.dig(row, col)
-    if (row == end_row) && (col == end_col)
-      current_tile.nil? || (current_tile.owner != @owner)
-    elsif current_tile.nil? || current_tile.equal?(self)
-      next_cell(row, col, end_row, end_col) => [next_row, next_col]
-      clear_path?(next_row, next_col, end_row, end_col, board)
-    else
-      false
-    end
-  end
-end
-
-class Pawn < ChessPiece
-  def initialize(owner, front)
-    super(owner, "p")
-    @first_move = true
-    @front = front
-  end
-
-  def valid_move?(row, col, end_row, end_col, board)
-    return false unless valid_forward_move?(row, end_row)
-
-    if col == end_col # only forward
-      valid_dest = board.dig(end_row, end_col).nil?
-      @first_move = false if valid_dest
-      return valid_dest
-    elsif (col - end_col).abs == 1 # diagonal movement
-      other_piece = board.dig(end_row, end_col)
-      return other_piece && (other_piece.owner != @owner)
-    end
-    false
-  end
-
-  private
-
-  def valid_forward_move?(row, end_row)
-    if @first_move
-      (row + @front * 2 == end_row) || (row + @front == end_row)
-    else
-      row + @front == end_row
-    end
-  end
-end
-
-class Queen < ChessPiece
-  def initialize(owner)
-    super(owner, "Q")
-  end
-
-  def valid_move?(row, col, end_row, end_col, board)
-    valid_diag_move?(row, col, end_row, end_col, board) \
-    || valid_horz_move?(row, col, end_row, end_col, board) \
-    || valid_vert_move?(row, col, end_row, end_col, board)
-  end
-end
-
-class Rook < ChessPiece
-  def initialize(owner)
-    super(owner, "R")
-  end
-
-  def valid_move?(row, col, end_row, end_col, board)
-    valid_horz_move?(row, col, end_row, end_col, board) \
-    || valid_vert_move?(row, col, end_row, end_col, board)
-  end
-end
-
-class Bishop < ChessPiece
-  def initialize(owner)
-    super(owner, "B")
-  end
-
-  def valid_move?(row, col, end_row, end_col, board)
-    valid_diag_move?(row, col, end_row, end_col, board)
-  end
-end
-
-class King < ChessPiece
-  def initialize(owner)
-    super(owner, "K")
-  end
-
-  def valid_move?(row, col, end_row, end_col, board)
-    return false unless (row - end_row).abs == 1 && (col - end_col).abs == 1
-
-    valid_diag_move?(row, col, end_row, end_col, board) \
-    || valid_horz_move?(row, col, end_row, end_col, board) \
-    || valid_vert_move?(row, col, end_row, end_col, board)
-  end
-end
-
-class Knight < ChessPiece
-  def initialize(owner)
-    # K was already taken by king, so I had to choose N
-    super(owner, "N")
-  end
-
-  def valid_move?(row, col, end_row, end_col, board)
-    within_movement(row, col, end_row, end_col) \
-    && not_occupied(end_row, end_col, board)
-  end
-
-  private
-
-  def within_movement(row, col, end_row, end_col)
-    ((row - end_row).abs == 2 and (col - end_col).abs == 1) \
-    || ((row - end_row).abs == 1 and (col - end_col).abs == 2)
-  end
-
-  def not_occupied(end_row, end_col, board)
-    spot = board.dig(end_row, end_col)
-    spot.nil? || spot.owner != @owner
-  end
-end

data/lib/boardgame_engine/connect4/connect4.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require "./lib/boardgame_engine"
-
-class Connect4Board < Board
-  def initialize
-    super(6, 7)
-  end
-
-  def display
-    super(show_col: true)
-  end
-
-  def drop_chip(col, owner)
-    @board.reverse_each do |row|
-      if row[col].nil?
-        row[col] = owner
-        break
-      end
-    end
-  end
-end
-
-class Connect4 < Boardgame
-  include TwoPlayers
-
-  @instructions = "You can select which column to drop you chip into by" \
-  " typing in the row number."
-
-  def initialize(name1 = "Player 1", name2 = "Player 2")
-    super(Connect4Board, @instructions, name1, name2)
-  end
-
-  def to_s
-    super("connect-four")
-  end
-
-  private
-
-  def valid_input?(input)
-    input.match?(/[[:digit:]]/) && input.to_i.between?(0, 6)
-  end
-
-  def play_turn
-    puts "#{@turn}'s turn. Choose a column to drop your chip in"
-    col = proper_format_input.to_i
-    @board.drop_chip(col, @turn)
-    @winner = @turn if win?
-    change_turn
-  end
-
-  def win?
-    [@board.board,
-     @board.board.transpose,
-     align_diagonally(@board.board),
-     align_diagonally(@board.board.transpose)].each do |config|
-      config.each { |direction| return true if four_in_a_row? direction }
-    end
-    false
-  end
-
-  def four_in_a_row?(row)
-    counts = row.chunk { |x| x }.map { |x, xs| [x, xs.length] }
-    return true if counts.any? { |x, count| count > 3 && !x.nil? }
-  end
-
-  def align_diagonally(board)
-    board.map.with_index do |row, idx|
-      left_filler = Array.new(board.length - 1 - idx, nil)
-      right_filler = Array.new(idx, nil)
-      left_filler + row + right_filler
-    end
-  end
-end