boardgame_engine 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e57f58857092b8b08b48de9bafcf09a08297302fcbe695afde86125615d07f1
-  data.tar.gz: c7de6b02681a7b7def284e31186fc61281fe9ae41dfe75464dc0a5e83b5bde9a
+  metadata.gz: c8a00224a55f64e290296e59c90686e9984141c43b3ce1d588cbe2a6f382d906
+  data.tar.gz: 83ec3bd763ae34688b1f99f8e2c54d9bc9c0229430fc80ae5211db81a9ce47a0
 SHA512:
-  metadata.gz: 2155a5ca5a0c871e277a7a0e4beb9ea25b86a17ada30481d4f37b6104385c300095ef61cd694b860cadc72ab9230f6f7d199934a15c96de3278b22756174b07c
-  data.tar.gz: accc0b89071a919f466be01d1ecd68bc4f2fe3096817ff6340b161e731beabe1e05142399af352922cf7ac521ee95711fc6681068cf5b083c3e7ba9fb51ca02f
+  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

@@ -3,142 +3,176 @@
 # 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 } }
+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
+
+    private
+
+    def spot_playable?(piece, row, col)
+      piece.possible_moves.include? [row, col]
+    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) }
+  # Class representing a player in a game
+  class Player
+    attr_reader :name
+
+    # Creates a player object with the given name
+    # @param [String] name
+    def initialize(name)
+      @name = name
     end
-    return unless show_col
 
-    column_spacer = show_row ? "  " : ""
-    puts(@board[0].each_index.reduce(column_spacer) do |str, idx|
-      str + " #{idx} "
-    end)
+    def to_s
+      @name.to_s
+    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
+  # 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"
 
-    destination
-  end
+    def initialize(board, instructions, names)
+      @players = names.map { |name| Player.new name }
+      @board = setup_board(board)
+      @instructions = instructions
+      @winner = nil
+    end
 
-  private
+    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
 
-  def format_row(row)
-    row.map { |elem| "[#{elem.nil? ? " " : elem}]" }.join
-  end
+      @game = new(names)
 
-  def spot_playable?(piece, row, col)
-    piece.possible_moves.include? [row, col]
-  end
-end
+      puts "Welcome to #{@game}!"
+      @game.onboarding if do_onboarding
+      puts "Starting #{@game}..."
+      @game.start
+    end
 
-# Class representing a player in a game
-class Player
-  attr_reader :name
+    def to_s(game_name = 'boardgame')
+      "#{game_name} between #{@players.join(', ')}"
+    end
 
-  def initialize(name)
-    @name = name
-  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
+      end
+    end
 
-  def to_s
-    @name.to_s
-  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'
+        input = gets.chomp
+      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
+    def start(turn = @players[0])
+      @turn = turn
+      @board.display
+      until @winner
+        play_turn
+        @board.display
+      end
+      puts "#{@winner} wins!"
+    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
+    protected
 
-  def to_s(game_name = "boardgame")
-    "#{game_name} between #{@player1} and #{@player2}"
-  end
+    def get_valid_board_input(special_commands = [])
+      input = gets.chomp
 
-  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
+      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
-  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"
-      input = gets.chomp
+    def setup_board(board)
+      board.new
     end
   end
 
-  def start(turn = @player1)
-    @turn = turn
-    @board.display
-    until @winner
-      play_turn
-      @board.display
+  class Piece
+    attr_accessor :status
+    attr_reader :owner
+
+    def initialize(owner, name)
+      @status = 'alive'
+      @owner = owner
+      @name = name
     end
-    puts "#{@winner} wins!"
-  end
 
-  protected
+    def kill(other)
+      other.status = 'dead'
+    end
 
-  def proper_format_input(special_commands = [])
-    input = gets.chomp
-    until valid_input?(input)
-      exit if input == "exit"
-      return input if special_commands.include?(input)
+    def to_s
+      @name.to_s
+    end
 
-      puts "Input is in the wrong format or out of bounds. Try again"
-      input = gets.chomp
+    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
-    input
-  end
 
-  def setup_board(board)
-    board.new
+    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

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+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)
+      @board = generate_board(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 Games::CyclicalTurn
+    include Games::MovablePiece
+
+    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')
+    end
+
+    private
+
+    def valid_piece?(piece)
+      !piece.nil? && piece.owner == @turn
+    end
+
+    def play_turn
+      puts "#{@turn}'s turn"
+      killed = play_move
+      @winner = @turn if killed.is_a?(King)
+      change_turn
+    end
+
+    def setup_board(board)
+      board.new(@players[0], @players[1])
+    end
+  end
+
+  class Pawn < BoardgameEngine::Piece
+    def initialize(owner, front)
+      super(owner, 'p')
+      @first_move = true
+      @front = front
+    end
+
+    # 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
+        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
+    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)
+      else
+        row + @front == end_row
+      end
+    end
+  end
+
+  class Queen < BoardgameEngine::Piece
+    def initialize(owner)
+      super(owner, 'Q')
+    end
+
+    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 < BoardgameEngine::Piece
+    def initialize(owner)
+      super(owner, 'R')
+    end
+
+    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 < BoardgameEngine::Piece
+    def initialize(owner)
+      super(owner, 'B')
+    end
+
+    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 < BoardgameEngine::Piece
+    def initialize(owner)
+      super(owner, 'K')
+    end
+
+    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
+
+      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 < BoardgameEngine::Piece
+    def initialize(owner)
+      # K was already taken by king, so I had to choose N
+      super(owner, 'N')
+    end
+
+    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
+
+    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,57 @@
+# frozen_string_literal: true
+
+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
+      @board = generate_board(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
+
+    def valid_board_input?(input)
+      super(input, only_col: true)
+    end
+  end
+
+  class Connect4 < BoardgameEngine::Boardgame
+    include Games::CyclicalTurn
+
+    @instructions = 'You can select which column to drop you chip into by' \
+    ' typing in the row number.'
+
+    def initialize(names)
+      super(Connect4Board, @instructions, names)
+    end
+
+    def to_s
+      super('connect-four')
+    end
+
+    private
+
+    def play_turn
+      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 @board.consecutive?
+      change_turn
+    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

@@ -0,0 +1,7 @@
+# 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.0"
+  VERSION = '0.2.0'
 end

data/lib/boardgame_engine.rb

@@ -1,12 +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_relative "boardgame_engine/boardgame"
-require_relative "boardgame_engine/multiplayergame"
-require_relative "boardgame_engine/chess/chess"
-require_relative "boardgame_engine/connect4/connect4"
-
-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.0
+  version: 0.2.0
 platform: ruby
 authors:
 - FortHoney
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-10-05 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,11 +39,12 @@ files:
 - Rakefile
 - boardgame_engine.gemspec
 - lib/boardgame_engine.rb
+- lib/boardgame_engine/board_modules.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/multiplayergame.rb
+- lib/boardgame_engine/chess.rb
+- lib/boardgame_engine/connect4.rb
+- lib/boardgame_engine/game_modules.rb
+- lib/boardgame_engine/sample_games.rb
 - lib/boardgame_engine/version.rb
 - sig/boardgame_engine.rbs
 homepage: https://github.com/Forthoney/boardgame_engine
@@ -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/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

data/lib/boardgame_engine/multiplayergame.rb

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