boardgame_engine 0.1.1 → 0.2.1

data/lib/boardgame_engine/chess.rb

@@ -1,191 +1,148 @@
 # 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
-    attr_reader :board
+# module for playing a game of chess
+module Chess
+  # Class for a game of chess
+  class Game < BoardgameEngine::Game
+    include Games::CyclicalTurn
+    include Games::MovablePiece
 
-    def initialize(player1, player2)
-      super(8, 8)
-      setup(player1, player2)
-    end
+    PLAY_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"
+    GAME_NAME = 'Chess'
+    NUM_PLAYERS = 2
 
-    def display
-      super(show_row: true, show_col: true)
+    def initialize(names)
+      super(Board, names)
     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
-
+    # Check whether a piece can be selected by the player
+    #
+    # @param [Piece] piece the piece being selected
+    #
+    # @return [Boolean] whether the piece exists and if so, if it belongs to
+    # the player currently going
     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
+      piece && piece.owner == @turn
     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
+      puts "#{@turn}'s turn"
+      killed = play_move
+      @winner = @turn if killed.is_a?(King)
     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
+  # Class for a chessboard
+  class Board
+    include Boards::Grid
+    include Boards::MovablePiece
 
-    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
+    attr_reader :board
 
-    def valid_horz_move?(row, col, end_row, end_col, board)
-      (end_row == row) && clear_path?(row, col, end_row, end_col, board)
+    def initialize(player1, player2)
+      @board = generate_board(8, 8)
+      setup(player1, player2)
     end
 
-    def valid_vert_move?(row, col, end_row, end_col, board)
-      (end_col == col) && clear_path?(row, col, end_row, end_col, board)
+    def display
+      super(show_row: true, show_col: true)
     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
+    def setup(player1, player2)
+      set_pawns(player1, player2)
+      set_non_pawns(player1, player2)
+    end
 
-      [row + row_move, col + col_move]
+    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 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
+    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 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 [Boolean] 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 +152,72 @@ 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)
+      board.clear_diag_path?(start_location, end_location) \
+      || board.clear_horz_path?(start_location, end_location) \
+      || board.clear_vert_path?(start_location, end_location)
     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
+
+      board.clear_horz_path?(row, col, end_row, end_col, board) \
+      || 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
+
+      board.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)
+      board.clear_diag_path?(row, col, end_row, end_col, board) \
+      || board.clear_horz_path?(row, col, end_row, end_col, board) \
+      || 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,18 +1,52 @@
 # 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 for playing a game of Connect-4
+module Connect4
+  # A game of Connect-4
+  class Game < BoardgameEngine::Game
+    include Games::CyclicalTurn
+
+    PLAY_INSTRUCTIONS = 'You can select which column to drop you chip into by' \
+    ' typing in the row number.'
+    GAME_NAME = 'Connect-4'
+    NUM_PLAYERS = 2
+
+    def initialize(names)
+      super(Board, names)
+    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? 4
+    end
+  end
+
+  # The Connect-4 board
+  class Board
+    include Boards::Grid
 
-module SampleConnect4
-  class Connect4Board < BoardgameEngine::Board
     def initialize
-      super(6, 7)
+      @board = generate_board(6, 7)
     end
 
     def display
       super(show_col: true)
     end
 
+    # Drop a chip from a certain player into a given column
+    #
+    # @param [Integer] col The column chosen by the player
+    # @param [Player] owner the player dropping the chip
+    #
+    # @return [void]
     def drop_chip(col, owner)
       @board.reverse_each do |row|
         if row[col].nil?
@@ -21,57 +55,9 @@ module SampleConnect4
         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
+    def valid_board_input?(input)
+      super(input, only_col: true)
     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, start_loc = select_piece_from_input
+      puts "Select where to move \"#{piece}\" to. Type \"back\" to reselect piece"
+      end_loc = select_destination(piece, start_loc)
+      return play_move if end_loc == 'back'
+
+      @board.move_piece(start_loc, end_loc)
+    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 [Piece] 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.1'
 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.1
 platform: ruby
 authors:
 - FortHoney
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-10-07 00:00:00.000000000 Z
+date: 2023-01-18 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