boardgame_engine 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8a00224a55f64e290296e59c90686e9984141c43b3ce1d588cbe2a6f382d906
-  data.tar.gz: 83ec3bd763ae34688b1f99f8e2c54d9bc9c0229430fc80ae5211db81a9ce47a0
+  metadata.gz: 8f3c14dd095359859bb7c6fb53b25e7c94ae18bb1b4e407d0e377797254930a6
+  data.tar.gz: 5ecf4d791871a327a1f2e2844cc21b5d0de4b23b001f478a8ef8ca89834bc803
 SHA512:
-  metadata.gz: c3d1d0647a5ff2b85b619aa85f72dc6a1f3638074a2333b22fed2535239c0feb64c43e4ac97eb98bbff45c77ebf513bd9d401299b8046483a2520dca005fdf1f
-  data.tar.gz: eb8768b54c655792cf5f5270ddcc30867b1afd4e80d8382e97704873742b1dd8964925ed1683eff327b386c0d0f9d2aebf454ff1ecfe4cd1bed326dfd1cb3c41
+  metadata.gz: 8a8579be5461dda2d3e77a4c2fa50b92ff0a6d4179f960e2ce083261bbc5db6cfe05defa5f1e679e07576bd517d2296477666b86f4388be30030b8127a2ce5ef
+  data.tar.gz: afd22e1654d2ca4a66f648e96d08cfd9f52ba3c780d19d4352344214dd6b753ba85236f8e2b0bbf47ecce2c1bd272ac6c33ed6592c0a96838db3c0ea50b327c5

data/Gemfile.lock

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

data/README.md

@@ -2,7 +2,7 @@
 
 A gem that provides a template for creating boardgames. It aims to streamline
 the process of making boardgames to be played on the terminal by providing a 
-variety of methods and classes.
+variety of classes and modules.
 
 ## Installation
 
@@ -15,8 +15,43 @@ If bundler is not being used to manage dependencies, install the gem by executin
     $ gem install boardgame_engine
 
 ## Usage
+### Initial Setup
+To start making your own boardgame using this gem, your game module needs at least two classes -
+a `Game` class inheriting from `Boardgame` and a `Board` class inheriting `Board`.
+`Game` captures the core gameplay loop/logic and the `Board` captures 
+interactions with the board.
 
-TODO: Write usage instructions here
+Depending on the game rules, select child modules from the `Games` and `Boards`
+and include it into the `Game` and `Board` class respectively.
+These modules will handle much of the game and board logic related to the
+game mechanic/rule.
+
+For example, if the turns in your game go in a cycle like 1 -> 2 -> 3 -> 1 -> 2 ...
+your `Game` class would look like
+```ruby
+class Game < BoardgameEngine::Game
+  include Games::CyclicalGame
+  NUM_PLAYERS = 3
+  ...
+end
+```
+Including this module makes it so that the `BoardgameEngine::Game#change_turn` 
+method automatically hands the turn over to the correct player.
+
+### Overriding
+At the current stage of the app, there are methods that necessarily must be
+overridden in the child class.
+`play_turn` must be implemented on _your_ `Game` class, and must contain what happens
+during a single turn (not a round, just a turn).
+
+Additionally, the limited number of modules mean that you will probably have to implement some
+methods on your own. I hope to reduce the number of these as the app matures.
+I left yard comments on all module methods, so hopefully overriding won't be too
+difficult.
+
+## Example Games
+Check out `connect4.rb` for a game built with rather minimal overrides and
+`chess.rb` for a game that makes heavy use of customization.
 
 ## Development
 
@@ -26,4 +61,9 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/Forthoney/boardgame_engine.
+Bug reports are welcome on GitHub at https://github.com/Forthoney/boardgame_engine.
+I may not get to them quickly but it will be greatly helpful
+
+As the app is under heavy development I will not look deeply into actually 
+pulling pull requests (if there were to be any).
+I will definitely consider the ideas proposed in them, so they are still welcome.

data/lib/boardgame_engine/board_modules.rb

@@ -4,17 +4,7 @@
 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 
+    # Print a visual representation of the board
     #
     # @param [Boolean] show_row whether to show row labels
     # @param [Boolean] show_col whether to show column labels
@@ -30,19 +20,42 @@ module Boards
       return unless show_col
 
       column_spacer = show_row ? '  ' : ''
-      puts format_col(column_spacer)
+      puts format_col_numbering(column_spacer)
     end
 
+    # Accessor for getting piece at a location on the board
+    #
+    # @param [Array<Integer, Integer>] location the coordinates on the grid to
+    # get the piece from
+    #
+    # @return [Piece] the piece at the location
     def get_piece_at(location)
       row, col = location
       @board.dig(row, col)
     end
 
+    # Setter for setting a piece at a location on the board
+    #
+    # @param [Array<Integer, Integer>] location <description>
+    # @param [Piece] piece the piece to place down
+    #
+    # @return [void]
     def set_piece_at(location, piece)
       row, col = location
       @board[row][col] = piece
     end
 
+    # Check whether the given input refers to a valid location on the board,
+    # regardless of placement of other pieces, rules, etc
+    #
+    # @param [String] input the user input
+    # @param [Boolean] only_row optional arg for only allowing user to specify
+    # row
+    # @param [Boolean] only_col optional arg for only allowing user to specify
+    # col
+    #
+    # @return [Boolean] true if the input can be parsed into a location on the
+    # board, false otherwise
     def valid_board_input?(input, only_row: false, only_col: false)
       if only_row || only_col
         input.match?(/[0-#{@board.length - 1}]/)
@@ -51,29 +64,154 @@ module Boards
       end
     end
 
+    # Check whether there exists a clear diagonal path from start to a
+    # destination
+    #
+    # @param [Array<Integer, Integer>] start_location the start location
+    # @param [Array<Integer, Integer>] end_location the intended destination
+    #
+    # @return [Boolean] true if there exists an unblocked path to destination
+    def clear_diag_path?(start_location, end_location)
+      row, col = start_location
+      end_row, end_col = end_location
+
+      ((end_row - row).abs == (end_col - col).abs) \
+      && clear_path?(row, col, end_row, end_col, board)
+    end
+
+    # Check whether there exists an unblocked horizontal path from start to
+    # a destination
+    #
+    # @param [Array<Integer, Integer>] start_location the start location
+    # @param [Array<Integer, Integer>] end_location the intended destination
+    #
+    # @return [Boolean] true if there exists an unblocked path to destination
+    def clear_horz_path?(start_location, end_location)
+      row, col = start_location
+      end_row, end_col = end_location
+
+      (end_row == row) && clear_path?(row, col, end_row, end_col, board)
+    end
+
+    # Check whether there exists an unblocked vertical path from start to
+    # a destination
+    #
+    # @param [Array<Integer, Integer>] start_location the start location
+    # @param [Array<Integer, Integer>] end_location the intended destination
+    #
+    # @return [Boolean] true if there exists an unblocked path to destination
+    def clear_vert_path?(start_location, end_location)
+      row, col = start_location
+      end_row, end_col = end_location
+
+      (end_col == col) && clear_path?(row, col, end_row, end_col, board)
+    end
+
+    # Parse an input from the user that has a corresponding board location. This
+    # must be used in after valid_board_input? has confirmed the input is in
+    # the correct format
+    #
+    # @param [String] input a valid
+    #
+    # @return [Array<Integer, Integer>]
     def parse_input(input)
       input.split(',').map(&:to_i)
     end
 
-    def consecutive?(row: true, col: true, diagonal: true)
+    # 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
+
+    # Check whether there are consecutive pieces on the board
+    #
+    # @param [Integer] num the number of consecutive pieces to check for.
+    # @param [Boolean] row check for row-wise consecutive pieces
+    # @param [Boolean] col check for column-wise consecutive pieces
+    # @param [Boolean] diagonal check for diagonally consecutive pieces
+    #
+    # @return [Boolean] true if any specified directins have num number of
+    # consecutive pieces
+    def consecutive?(num, 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) }
+        board.each { |array| return true if row_consecutive?(num, array) }
       end
       false
     end
 
     private
 
+    # calculates the location of the next cell in the sequence of cells from a
+    # given start location and an end location
+    #
+    # @param [Integer] row
+    # @param [Integer] col
+    # @param [Integer] end_row
+    # @param [Integer] end_col
+    #
+    # @return [Array<Integer, Integer>] the next cell in the sequence of cells
+    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
+
+    # Given a linear path, check whether there exists an unblocked path.
+    # It msut be checked beforehand that the path is indeed linear
+    #
+    # @param [Integer] row
+    # @param [Integer] col
+    # @param [Integer] end_row
+    # @param [Integer] end_col
+    #
+    # @return [Boolean] true if there exists a clear path
+    def clear_path?(row, col, end_row, end_col)
+      current_tile = get_piece_at([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)
+      else
+        false
+      end
+    end
+
+    # Check a single row for consecutive pieces
+    #
+    # @param [Integer] num the number of consecutive pieces to check for
+    # @param [Array] array the row to check in
+    #
+    # @return [Boolean] true if there are at least num number of consecutive
+    # elements
     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 }
+      chunked_elems = array.chunk { |elem| elem }
+      elem_counts = chunked_elems.map { |elem, elems| [elem, elems.length] }
+      elem_counts.any? { |elem, count| count >= num && elem }
     end
 
+    # Align the diagonals of a board. Must be called once on the original board
+    # and once more on the transposed board to check for both directions of
+    # diagonals
+    #
+    # @param [Array<Array>] board the board to align
+    #
+    # @return [Array<Array>] new board with the diagonals aligned
     def align_diagonal(board)
       board.map.with_index do |row, idx|
         left_filler = Array.new(board.length - 1 - idx, nil)
@@ -82,17 +220,36 @@ module Boards
       end
     end
 
+    # Format a single row for String representation
+    #
+    # @param [Array] row the row to turn into a String
+    #
+    # @return [String] a String representation of the row
     def format_row(row)
       row.map { |elem| "[#{elem.nil? ? ' ' : elem}]" }.join
     end
 
-    def format_col(column_spacer)
+    # Format the column numbering of a board
+    #
+    # @param [String] column_spacer the spacer to use between the indices
+    #
+    # @return [String] a String representation of the row
+    def format_col_numbering(column_spacer)
       @board[0].each_index.reduce(column_spacer) { |str, idx| str + " #{idx} " }
     end
   end
 
   # Boards with movable pieces
   module MovablePiece
+    # Move a piece from at a start location to an end location. Should be called
+    # after checking that the movement is valid board and game logic wise.
+    #
+    # @param [<Type>] start_location the starting location of the piece
+    # @param [<Type>] end_location the destination of the piece
+    # @param [<Type>] set_start_to what to place at the start location. defaults
+    # to nil
+    #
+    # @return [Piece] the piece at the destination
     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)

data/lib/boardgame_engine/boardgame.rb

@@ -2,52 +2,44 @@
 
 # All classes in this script are intended to be abstract, meaning they should
 # not be called on their own.
-
 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
-
   # Class representing a player in a game
   class Player
     attr_reader :name
 
     # Creates a player object with the given name
-    # @param [String] name
+    #
+    # @param [String] name the name of the player
     def initialize(name)
       @name = name
     end
 
+    # String representation of player
+    #
+    # @return [String] the name of the player
     def to_s
       @name.to_s
     end
   end
 
-  # Class representing a board game.
-  class Boardgame
+  # Class representing the game loop. It contains the tutorial sequence and
+  # information about the core gameplay loop
+  class Game
+    PLAY_INSTRUCTIONS = ''
     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, names)
-      @players = names.map { |name| Player.new name }
-      @board = setup_board(board)
-      @instructions = instructions
-      @winner = nil
-    end
-
-    def self.play(do_onboarding: true, num_players: 2)
+    GAME_NAME = 'Boardgame'
+    NUM_PLAYERS = 2
+
+    # Begins a round of the Game
+    #
+    # @param [Boolean] do_onboarding optional argument on whether to do
+    # onboarding
+    #
+    # @return [void]
+    def self.start(do_onboarding: true)
       names = []
-      num_players.times do |i|
+      self::NUM_PLAYERS.times do |i|
         puts "What is Player #{i}'s name?"
         names.push(gets.chomp)
       end
@@ -57,13 +49,13 @@ module BoardgameEngine
       puts "Welcome to #{@game}!"
       @game.onboarding if do_onboarding
       puts "Starting #{@game}..."
-      @game.start
-    end
-
-    def to_s(game_name = 'boardgame')
-      "#{game_name} between #{@players.join(', ')}"
+      @game.play
     end
 
+    # Execute onboarding sequence where the player is asked if they want a
+    # tutorial
+    #
+    # @return [void]
     def onboarding
       puts "Would you like a tutorial on how to play on this program? \n(y, n)"
 
@@ -78,28 +70,60 @@ module BoardgameEngine
       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
-
-    def start(turn = @players[0])
+    # Play the game
+    #
+    # @param [Player] turn the player who is going first
+    #
+    # @return [void]
+    def play(turn = @players[0])
       @turn = turn
       @board.display
       until @winner
         play_turn
         @board.display
+        change_turn
       end
       puts "#{@winner} wins!"
     end
 
+    # String representation of the game
+    #
+    # @return [String] <description>
+    def to_s
+      "#{self.class::GAME_NAME} between #{@players.join(', ')}"
+    end
+
     protected
 
+    # Constructor for a board game. Kept private so that an object of just class
+    # BoardGame cannot be instantiated without being inherited. It essentially
+    # keeps it as an abstract class
+    #
+    # @param [Board] board the board to play on
+    # @param [Array<String>] names the names of the players
+    def initialize(board, names)
+      @players = names.map { |name| Player.new name }
+      @board = setup_board(board)
+      @winner = nil
+    end
+
+    # Run tutorial for the game
+    def tutorial
+      puts self.class::PLAY_INSTRUCTIONS + self.class::EXIT_INSTRUCTIONS
+      input = gets.chomp
+      until input == 'back'
+        exit if input == 'exit'
+        puts @board.valid_board_input?(input) ? 'Valid input' : 'Invalid input'
+        input = gets.chomp
+      end
+    end
+
+    # Prompts a user for a board input until a proper input is received
+    #
+    # @param [Array<String>] special_commands a list of commands that are not
+    # valid board input but are valid commands like "back"
+    #
+    # @return [String] a valid input
     def get_valid_board_input(special_commands = [])
       input = gets.chomp
 
@@ -113,6 +137,11 @@ module BoardgameEngine
       input
     end
 
+    # Setup the board
+    #
+    # @param [Class] board the class of the board to be used in the game
+    #
+    # @return [Board] a new board
     def setup_board(board)
       board.new
     end
@@ -135,44 +164,5 @@ module BoardgameEngine
     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

@@ -4,8 +4,47 @@ require 'boardgame_engine/boardgame'
 require 'boardgame_engine/game_modules'
 require 'boardgame_engine/board_modules'
 
-module SampleChess
-  class ChessBoard < BoardgameEngine::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
+
+    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 initialize(names)
+      super(Board, names)
+    end
+
+    private
+
+    # 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 && piece.owner == @turn
+    end
+
+    def play_turn
+      puts "#{@turn}'s turn"
+      killed = play_move
+      @winner = @turn if killed.is_a?(King)
+    end
+
+    def setup_board(board)
+      board.new(@players[0], @players[1])
+    end
+  end
+
+  # Class for a chessboard
+  class Board
     include Boards::Grid
     include Boards::MovablePiece
 
@@ -41,38 +80,6 @@ module SampleChess
     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')
@@ -86,7 +93,7 @@ module SampleChess
     # @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
+    # @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
@@ -151,12 +158,9 @@ module SampleChess
     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)
+      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
 
@@ -169,8 +173,8 @@ module SampleChess
       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)
+      board.clear_horz_path?(row, col, end_row, end_col, board) \
+      || board.clear_vert_path?(row, col, end_row, end_col, board)
     end
   end
 
@@ -183,7 +187,7 @@ module SampleChess
       row, col = start_location
       end_row, end_col = end_location
 
-      clear_diag_path?(row, col, end_row, end_col, board)
+      board.clear_diag_path?(row, col, end_row, end_col, board)
     end
   end
 
@@ -198,9 +202,9 @@ module SampleChess
 
       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)
+      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
 

data/lib/boardgame_engine/connect4.rb

@@ -4,8 +4,33 @@ require 'boardgame_engine/boardgame'
 require 'boardgame_engine/game_modules'
 require 'boardgame_engine/board_modules'
 
-module SampleConnect4
-  class Connect4Board < BoardgameEngine::Board
+# 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
 
     def initialize
@@ -16,6 +41,12 @@ module SampleConnect4
       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?
@@ -29,29 +60,4 @@ module SampleConnect4
       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

@@ -18,12 +18,12 @@ module Games
     # @return [void]
     def play_move
       puts 'Select your piece'
-      piece, row, col = select_piece_from_input
+      piece, start_loc = 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'
+      end_loc = select_destination(piece, start_loc)
+      return play_move if end_loc == 'back'
 
-      @board.move_piece([row, col], dest)
+      @board.move_piece(start_loc, end_loc)
     end
 
     private
@@ -45,7 +45,7 @@ module Games
 
     # Select a location on the board to move to from user input
     #
-    # @param [<Type>] piece The piece to move
+    # @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'

data/lib/boardgame_engine/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: boardgame_engine
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - FortHoney
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-01-17 00:00:00.000000000 Z
+date: 2023-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec