boardgame_engine 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7129074317f7ea44e65ad18e5952e2401e47be99186e26dd42b0c083ebc91797
-  data.tar.gz: f87aebcb6502cbfd9d8ee04e60b775f1497e09527863f3f820a1edb202297330
+  metadata.gz: c8a00224a55f64e290296e59c90686e9984141c43b3ce1d588cbe2a6f382d906
+  data.tar.gz: 83ec3bd763ae34688b1f99f8e2c54d9bc9c0229430fc80ae5211db81a9ce47a0
 SHA512:
-  metadata.gz: 1c1ab01918757d936b1ee97cf8d75bbf19a300e71450b0c1896fcd9cdda0f804b25324b71ef01929d8d231f96ef7af15ec023690dc52d5a738e8b363da43c4f8
-  data.tar.gz: b10198cde214fe10e7a861a27419e6235b25a84ef1fac0992de66e0297668da8e3f600effaae0049c12a5343e761dccfb623594bc2621d40b24063e8b8d82cb0
+  metadata.gz: c3d1d0647a5ff2b85b619aa85f72dc6a1f3638074a2333b22fed2535239c0feb64c43e4ac97eb98bbff45c77ebf513bd9d401299b8046483a2520dca005fdf1f
+  data.tar.gz: eb8768b54c655792cf5f5270ddcc30867b1afd4e80d8382e97704873742b1dd8964925ed1683eff327b386c0d0f9d2aebf454ff1ecfe4cd1bed326dfd1cb3c41

data/.rubocop.yml

@@ -1,13 +1,5 @@
 AllCops:
-  TargetRubyVersion: 3.1
-
-Style/StringLiterals:
-  Enabled: true
-  EnforcedStyle: double_quotes
-
-Style/StringLiteralsInInterpolation:
-  Enabled: true
-  EnforcedStyle: double_quotes
+  TargetRubyVersion: 3.0
 
 Layout/LineLength:
   Max: 120

data/Gemfile

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
 # Specify your gem's dependencies in boardgame_engine.gemspec
 gemspec
 
-gem "rake", "~> 13.0"
+gem 'rake', '~> 13.0'
 
-gem "rubocop", "~> 1.21"
+gem 'rubocop', '~> 1.21'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    boardgame_engine (0.1.0)
+    boardgame_engine (0.1.1)
 
 GEM
   remote: https://rubygems.org/

data/Rakefile

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rubocop/rake_task"
+require 'bundler/gem_tasks'
+require 'rubocop/rake_task'
 
 RuboCop::RakeTask.new
 

data/boardgame_engine.gemspec

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
-require_relative "lib/boardgame_engine/version"
+require_relative 'lib/boardgame_engine/version'
 
 Gem::Specification.new do |spec|
-  spec.name = "boardgame_engine"
+  spec.name = 'boardgame_engine'
   spec.version = BoardgameEngine::VERSION
-  spec.authors = ["FortHoney"]
-  spec.email = ["castlehoneyjung@gmail.com"]
+  spec.authors = ['FortHoney']
+  spec.email = ['castlehoneyjung@gmail.com']
 
-  spec.summary = "A gem that makes digitizing/creating board games to be played on the terminal quick and easy."
-  spec.homepage = "https://github.com/Forthoney/boardgame_engine"
-  spec.required_ruby_version = ">= 2.7.0"
+  spec.summary = 'A gem that makes digitizing/creating board games to be played on the terminal quick and easy.'
+  spec.homepage = 'https://github.com/Forthoney/boardgame_engine'
+  spec.required_ruby_version = '>= 3.0.0'
 
   # spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
 
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/Forthoney/boardgame_engine"
-  spec.metadata["changelog_uri"] = "https://github.com/Forthoney/boardgame_engine/blob/main/CHANGELOG.md"
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/Forthoney/boardgame_engine'
+  spec.metadata['changelog_uri'] = 'https://github.com/Forthoney/boardgame_engine/blob/main/CHANGELOG.md'
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -25,11 +25,11 @@ Gem::Specification.new do |spec|
       (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
     end
   end
-  spec.bindir = "exe"
+  spec.bindir = 'exe'
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency 'rspec', '~> 3.2'
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html

data/lib/boardgame_engine/board_modules.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# Module for different board types
+module Boards
+  # Boards laid out in grid format
+  module Grid
+    # Make a 2D Array representing the board
+    #
+    # @param [Integer] row the number of rows
+    # @param [Integer] col the number of columns
+    #
+    # @return [Array<Array>] A 2D Array
+    def generate_board(row, col)
+      Array.new(row) { Array.new(col) { nil } }
+    end
+
+    # Print a visual representation of the 
+    #
+    # @param [Boolean] show_row whether to show row labels
+    # @param [Boolean] show_col whether to show column labels
+    #
+    # @return [void]
+    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 format_col(column_spacer)
+    end
+
+    def get_piece_at(location)
+      row, col = location
+      @board.dig(row, col)
+    end
+
+    def set_piece_at(location, piece)
+      row, col = location
+      @board[row][col] = piece
+    end
+
+    def valid_board_input?(input, only_row: false, only_col: false)
+      if only_row || only_col
+        input.match?(/[0-#{@board.length - 1}]/)
+      else
+        input.match?(/[0-#{@board.length - 1}], [0-#{@board[0].length - 1}]$/)
+      end
+    end
+
+    def parse_input(input)
+      input.split(',').map(&:to_i)
+    end
+
+    def consecutive?(row: true, col: true, diagonal: true)
+      configs = []
+      configs << @board if row
+      configs << @board.transpose if col
+      configs << align_diagonal(@board) << align_diagonal(@board.transpose) if diagonal
+
+      configs.each do |board|
+        board.each { |array| return true if row_consecutive?(4, array) }
+      end
+      false
+    end
+
+    private
+
+    def row_consecutive?(num, array)
+      elem_counts = array.chunk { |x| x }.map { |x, xs| [x, xs.length] }
+      elem_counts.any? { |x, count| count >= num && x }
+    end
+
+    def align_diagonal(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
+
+    def format_row(row)
+      row.map { |elem| "[#{elem.nil? ? ' ' : elem}]" }.join
+    end
+
+    def format_col(column_spacer)
+      @board[0].each_index.reduce(column_spacer) { |str, idx| str + " #{idx} " }
+    end
+  end
+
+  # Boards with movable pieces
+  module MovablePiece
+    def move_piece(start_location, end_location, set_start_to: nil)
+      piece = get_piece_at(start_location)
+      set_piece_at(start_location, set_start_to)
+      destination_piece = get_piece_at(end_location)
+      set_piece_at(end_location, piece)
+
+      destination_piece
+    end
+  end
+end

data/lib/boardgame_engine/boardgame.rb

@@ -11,39 +11,8 @@ module BoardgameEngine
   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) }
-      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
-
-      destination
-    end
-
     private
 
-    def format_row(row)
-      row.map { |elem| "[#{elem.nil? ? " " : elem}]" }.join
-    end
-
     def spot_playable?(piece, row, col)
       piece.possible_moves.include? [row, col]
     end
@@ -53,6 +22,8 @@ module BoardgameEngine
   class Player
     attr_reader :name
 
+    # Creates a player object with the given name
+    # @param [String] name
     def initialize(name)
       @name = name
     end
@@ -62,25 +33,26 @@ module BoardgameEngine
     end
   end
 
-  # Class for running a board game.
+  # Class representing 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)
+    def initialize(board, instructions, names)
+      @players = names.map { |name| Player.new name }
       @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)
+    def self.play(do_onboarding: true, num_players: 2)
+      names = []
+      num_players.times do |i|
+        puts "What is Player #{i}'s name?"
+        names.push(gets.chomp)
+      end
+
+      @game = new(names)
 
       puts "Welcome to #{@game}!"
       @game.onboarding if do_onboarding
@@ -88,17 +60,18 @@ module BoardgameEngine
       @game.start
     end
 
-    def to_s(game_name = "boardgame")
-      "#{game_name} between #{@player1} and #{@player2}"
+    def to_s(game_name = 'boardgame')
+      "#{game_name} between #{@players.join(', ')}"
     end
 
     def onboarding
       puts "Would you like a tutorial on how to play on this program? \n(y, n)"
+
       case gets.chomp
-      when "y"
+      when 'y'
         tutorial
-      when "n"
-        puts "Skipping tutorial"
+      when 'n'
+        puts 'Skipping Tutorial'
       else
         puts 'Please answer either "y" or "n"'
         onboarding
@@ -108,14 +81,14 @@ module BoardgameEngine
     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"
+      until input == 'back'
+        exit if input == 'exit'
+        puts valid_input?(input) ? 'Valid input!' : 'Invalid input'
         input = gets.chomp
       end
     end
 
-    def start(turn = @player1)
+    def start(turn = @players[0])
       @turn = turn
       @board.display
       until @winner
@@ -127,15 +100,16 @@ module BoardgameEngine
 
     protected
 
-    def proper_format_input(special_commands = [])
+    def get_valid_board_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"
+      until @board.valid_board_input?(input) || special_commands.include?(input)
+        exit if input == 'exit'
+
+        puts 'Invalid input. Try again'
         input = gets.chomp
       end
+
       input
     end
 
@@ -143,4 +117,62 @@ module BoardgameEngine
       board.new
     end
   end
+
+  class Piece
+    attr_accessor :status
+    attr_reader :owner
+
+    def initialize(owner, name)
+      @status = 'alive'
+      @owner = owner
+      @name = name
+    end
+
+    def kill(other)
+      other.status = 'dead'
+    end
+
+    def to_s
+      @name.to_s
+    end
+
+    protected
+
+    def clear_diag_path?(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 clear_horz_path?(row, col, end_row, end_col, board)
+      (end_row == row) && clear_path?(row, col, end_row, end_col, board)
+    end
+
+    def clear_vert_path?(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_row, next_col = next_cell(row, col, end_row, end_col)
+        clear_path?(next_row, next_col, end_row, end_col, board)
+      else
+        false
+      end
+    end
+  end
 end

data/lib/boardgame_engine/chess.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
-require_relative "boardgame"
-require_relative "multiplayergame"
+require 'boardgame_engine/boardgame'
+require 'boardgame_engine/game_modules'
+require 'boardgame_engine/board_modules'
 
 module SampleChess
   class ChessBoard < BoardgameEngine::Board
+    include Boards::Grid
+    include Boards::MovablePiece
+
     attr_reader :board
 
     def initialize(player1, player2)
-      super(8, 8)
+      @board = generate_board(8, 8)
       setup(player1, player2)
     end
 
@@ -38,154 +42,100 @@ module SampleChess
   end
 
   class Chess < BoardgameEngine::Boardgame
-    include TwoPlayers
+    include Games::CyclicalTurn
+    include Games::MovablePiece
 
-    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)
+    def initialize(names)
+      @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, names)
     end
 
     def to_s
-      super("chess")
+      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)
+      puts "#{@turn}'s turn"
+      killed = play_move
+      @winner = @turn if killed.is_a?(King)
       change_turn
     end
 
     def setup_board(board)
-      board.new(@player1, @player2)
+      board.new(@players[0], @players[1])
     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
+  class Pawn < BoardgameEngine::Piece
     def initialize(owner, front)
-      super(owner, "p")
+      super(owner, 'p')
       @first_move = true
       @front = front
     end
 
-    def valid_move?(row, col, end_row, end_col, board)
+    # Check whether the intended destination is a valid destination
+    #
+    # @param [Array<Integer, Integer>] start_location the start coords
+    # @param [Array<Integer, Integer>] end_location the intended destination
+    # @param [ChessBoard] board the chess board
+    #
+    # @return [<Type>] whether the pawn can move to the intended destination
+    def valid_move?(start_location, end_location, board)
+      row, col = start_location
+      end_row, end_col = end_location
+
+      # Checks if moving 1 (or 2 if its the first move) cell forward
       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)
+      if col == end_col
+        valid_line_move?(end_row, end_col, board)
+      elsif (col - end_col).abs == 1 && (row + @front == end_row)
+        valid_diag_move?(end_row, end_col, board)
+      else
+        false
       end
-      false
     end
 
     private
 
+    # Check if the pawn can move in a straight line forward to the specified
+    # coord
+    #
+    # @param [Integer] end_row the destination row number
+    # @param [Integer] end_col the destination column number
+    #
+    # @return [Boolean] whether the pawn can move or not
+    def valid_line_move?(end_row, end_col, board)
+      is_valid_dest = board.get_piece_at([end_row, end_col]).nil?
+      @first_move = false if is_valid_dest
+      is_valid_dest
+    end
+
+    # Check if the pawn can move in a diagonal line to the specified coord
+    #
+    # @param [Integer] end_row the destination row number
+    # @param [Integer] end_col the destination column number
+    #
+    # @return [Boolean] whether the pawn can move or not
+    def valid_diag_move?(end_row, end_col, board)
+      other_piece = board.get_piece_at([end_row, end_col])
+      @first_move = false if other_piece
+      other_piece && (other_piece.owner != @owner)
+    end
+
+    # Check if the pawn movement is valid row-wise
+    #
+    # @param [Integer] row the row the pawn starts from
+    # @param [Integer] end_row the destination row
+    #
+    # @return [Boolean] whether the pawn's row movement is valid numerically
     def valid_forward_move?(row, end_row)
       if @first_move
         (row + @front * 2 == end_row) || (row + @front == end_row)
@@ -195,60 +145,75 @@ module SampleChess
     end
   end
 
-  class Queen < ChessPiece
+  class Queen < BoardgameEngine::Piece
     def initialize(owner)
-      super(owner, "Q")
+      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)
+    def valid_move?(start_location, end_location, board)
+      row, col = start_location
+      end_row, end_col = end_location
+
+      clear_diag_path?(row, col, end_row, end_col, board) \
+      || clear_horz_path?(row, col, end_row, end_col, board) \
+      || clear_vert_path?(row, col, end_row, end_col, board)
     end
   end
 
-  class Rook < ChessPiece
+  class Rook < BoardgameEngine::Piece
     def initialize(owner)
-      super(owner, "R")
+      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)
+    def valid_move?(start_location, end_location, board)
+      row, col = start_location
+      end_row, end_col = end_location
+
+      clear_horz_path?(row, col, end_row, end_col, board) \
+      || clear_vert_path?(row, col, end_row, end_col, board)
     end
   end
 
-  class Bishop < ChessPiece
+  class Bishop < BoardgameEngine::Piece
     def initialize(owner)
-      super(owner, "B")
+      super(owner, 'B')
     end
 
-    def valid_move?(row, col, end_row, end_col, board)
-      valid_diag_move?(row, col, end_row, end_col, board)
+    def valid_move?(start_location, end_location, board)
+      row, col = start_location
+      end_row, end_col = end_location
+
+      clear_diag_path?(row, col, end_row, end_col, board)
     end
   end
 
-  class King < ChessPiece
+  class King < BoardgameEngine::Piece
     def initialize(owner)
-      super(owner, "K")
+      super(owner, 'K')
     end
 
-    def valid_move?(row, col, end_row, end_col, board)
+    def valid_move?(start_location, end_location, board)
+      row, col = start_location
+      end_row, end_col = end_location
+
       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)
+      clear_diag_path?(row, col, end_row, end_col, board) \
+      || clear_horz_path?(row, col, end_row, end_col, board) \
+      || clear_vert_path?(row, col, end_row, end_col, board)
     end
   end
 
-  class Knight < ChessPiece
+  class Knight < BoardgameEngine::Piece
     def initialize(owner)
       # K was already taken by king, so I had to choose N
-      super(owner, "N")
+      super(owner, 'N')
     end
 
-    def valid_move?(row, col, end_row, end_col, board)
+    def valid_move?(start_location, end_location, board)
+      row, col = start_location
+      end_row, end_col = end_location
+
       within_movement(row, col, end_row, end_col) \
       && not_occupied(end_row, end_col, board)
     end

data/lib/boardgame_engine/connect4.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
-require_relative "boardgame"
-require_relative "multiplayergame"
+require 'boardgame_engine/boardgame'
+require 'boardgame_engine/game_modules'
+require 'boardgame_engine/board_modules'
 
 module SampleConnect4
   class Connect4Board < BoardgameEngine::Board
+    include Boards::Grid
+
     def initialize
-      super(6, 7)
+      @board = generate_board(6, 7)
     end
 
     def display
@@ -21,57 +24,34 @@ module SampleConnect4
         end
       end
     end
+
+    def valid_board_input?(input)
+      super(input, only_col: true)
+    end
   end
 
   class Connect4 < BoardgameEngine::Boardgame
-    include TwoPlayers
+    include Games::CyclicalTurn
 
-    @instructions = "You can select which column to drop you chip into by" \
-    " typing in the row number."
+    @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)
+    def initialize(names)
+      super(Connect4Board, @instructions, names)
     end
 
     def to_s
-      super("connect-four")
+      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
+      puts "#{@turn}'s turn\nChoose a column to drop your chip in"
+      col = get_valid_board_input.to_i
       @board.drop_chip(col, @turn)
-      @winner = @turn if win?
+      @winner = @turn if @board.consecutive?
       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/game_modules.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# Module for different game rules
+module Games
+  # Module for games with a cyclical turn system
+  module CyclicalTurn
+    # Changes the turn to the next player
+    def change_turn
+      idx = @players.find_index(@turn)
+      @turn = @players[(idx + 1) % @players.length]
+    end
+  end
+
+  # Module for games where game pieces are moved
+  module MovablePiece
+    # Execute a single move according to player input
+    #
+    # @return [void]
+    def play_move
+      puts 'Select your piece'
+      piece, row, col = select_piece_from_input
+      puts "Select where to move \"#{piece}\" to. Type \"back\" to reselect piece"
+      dest = select_destination(piece, row, col)
+      return play_move if dest == 'back'
+
+      @board.move_piece([row, col], dest)
+    end
+
+    private
+
+    # Select a piece on the board from user input
+    #
+    # @return [Array] the piece, and the piece's location
+    def select_piece_from_input
+      location = @board.parse_input(get_valid_board_input)
+      piece = @board.get_piece_at(location)
+
+      if valid_piece?(piece)
+        [piece, location]
+      else
+        puts 'Invalid piece. Try again'
+        select_piece_from_input
+      end
+    end
+
+    # Select a location on the board to move to from user input
+    #
+    # @param [<Type>] piece The piece to move
+    # @param [<Type>] start_location the starting location of the piece
+    #
+    # @return [<Type>] the location of the piece or the string literal 'back'
+    def select_destination(piece, start_location)
+      input = get_valid_board_input(['back'])
+      return 'back' if input == 'back'
+
+      end_location = @board.parse_input(input)
+      if piece.valid_move?(start_location, end_location, @board)
+        end_location
+      else
+        puts 'Invalid destination. Try again'
+        select_destination(piece, start_location)
+      end
+    end
+  end
+end

data/lib/boardgame_engine/sample_games.rb

@@ -1,5 +1,7 @@
-require_relative "chess"
-require_relative "connect4"
+# frozen_string_literal: true
+
+require 'boardgame_engine/chess'
+require 'boardgame_engine/connect4'
 
 module SampleGames
 end

data/lib/boardgame_engine/version.rb

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

data/lib/boardgame_engine.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "boardgame_engine/version"
+require 'boardgame_engine/version'
+require 'boardgame_engine/boardgame'
+require 'boardgame_engine/game_modules'
+require 'boardgame_engine/board_modules'
+require 'boardgame_engine/sample_games'
 
-require "boardgame_engine/boardgame"
-require "boardgame_engine/multiplayergame"
-require "boardgame_engine/sample_games"
-
-module BoardgameEngine
-  class Error < StandardError; end
-end
+module BoardgameEngine end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: boardgame_engine
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - FortHoney
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-10-07 00:00:00.000000000 Z
+date: 2023-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -24,7 +24,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
-description:
+description: 
 email:
 - castlehoneyjung@gmail.com
 executables: []
@@ -39,10 +39,11 @@ files:
 - Rakefile
 - boardgame_engine.gemspec
 - lib/boardgame_engine.rb
+- lib/boardgame_engine/board_modules.rb
 - lib/boardgame_engine/boardgame.rb
 - lib/boardgame_engine/chess.rb
 - lib/boardgame_engine/connect4.rb
-- lib/boardgame_engine/multiplayergame.rb
+- lib/boardgame_engine/game_modules.rb
 - lib/boardgame_engine/sample_games.rb
 - lib/boardgame_engine/version.rb
 - sig/boardgame_engine.rbs
@@ -52,7 +53,7 @@ metadata:
   homepage_uri: https://github.com/Forthoney/boardgame_engine
   source_code_uri: https://github.com/Forthoney/boardgame_engine
   changelog_uri: https://github.com/Forthoney/boardgame_engine/blob/main/CHANGELOG.md
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -60,15 +61,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.4.4
+signing_key: 
 specification_version: 4
 summary: A gem that makes digitizing/creating board games to be played on the terminal
   quick and easy.

data/lib/boardgame_engine/multiplayergame.rb

@@ -1,5 +0,0 @@
-module TwoPlayers
-  def change_turn
-    @turn = @turn == @player1 ? @player2 : @player1
-  end
-end