connect_four_ab_akh 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6b387897fe28e78c797bf4fd362b16c37f71fb8ee2f685d3b43b443a34059c86
+  data.tar.gz: b8cefe8b70ee775018c0a0b3250bef78dea52f2a620876701cec1b0a606f348c
+SHA512:
+  metadata.gz: e4ea54a6790bf8be65340b7b003eede9f9b20b73e1632643531aa325df4f1b318a110af2ee69de795335a264ed8603c8bf908fb96b1f0d29cb53a3ceb46dc4b6
+  data.tar.gz: e9c4e766cf57c0f83afca95a4b9905ee5689eda735c979267c23817413bcf57dcb66e5aab035f64b1e39f60b7950056db2efaf4b266b252cd33ddd620736fa39

data/bin/connect_four_ab_akh

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require './lib/board'
+require './lib/turn'
+require './lib/game'
+require './lib/player'
+
+input = ""
+
+until input == 'q'
+    puts
+    puts " ---------------------------------------------------"
+    puts "|       Enter 'p' to play OR Enter 'q' to quit      |"
+    puts " ---------------------------------------------------"
+    input = gets.chomp
+
+    if input == 'q'
+        break
+    elsif input == 'p'
+        game = Game.new
+
+        puts
+        puts game.welcome_user
+        puts "----------------------------------------------------"
+        puts game.start
+        puts
+
+        input = ""
+    else
+        "Invalid input"
+    end
+end

data/lib/board.rb

@@ -0,0 +1,33 @@
+class Board
+  attr_reader :layout
+
+  def initialize
+    @layout = build_board
+  end
+
+  def build_board
+    new_board = {}
+    col = ["A", "B", "C", "D", "E", "F", "G"]
+
+    #Creates 7 columns
+    7.times do |i|
+
+        #Creates 6 rows
+        6.times do |j|
+            #Determine row
+            row = j + 1
+
+            #Creates the key symbol for new_board hash
+            key = col[i] + row.to_s
+
+            #Putting key => value pair into new_board hash
+            new_board[key.to_sym] = {
+                column: i+1,
+                row: row,
+                checker: nil
+            }
+        end
+    end
+    new_board
+  end
+end

data/lib/connect_four_ab_akh.rb

@@ -0,0 +1,30 @@
+require './lib/board'
+require './lib/turn'
+require './lib/game'
+require './lib/player'
+
+input = ""
+
+until input == 'q'
+    puts
+    puts " ---------------------------------------------------"
+    puts "|       Enter 'p' to play OR Enter 'q' to quit      |"
+    puts " ---------------------------------------------------"
+    input = gets.chomp
+
+    if input == 'q'
+        break
+    elsif input == 'p'
+        game = Game.new
+
+        puts
+        puts game.welcome_user
+        puts "----------------------------------------------------"
+        puts game.start
+        puts
+
+        input = ""
+    else
+        "Invalid input"
+    end
+end

data/lib/game.rb

@@ -0,0 +1,114 @@
+class Game
+    attr_reader :board,
+                :player,
+                :computer
+
+    def initialize
+        @board = Board.new
+        @player1 = Player.new("Player", "X")
+        @player2 = Player.new("Computer", "O")
+    end
+
+    def welcome_user
+       "              Welcome to CONNECT FOUR"
+    end
+
+    def print_board
+        # Create board string accumulator 
+        board_string = " A  B  C  D  E  F  G\n"
+        counter = 6
+
+        # Add each board cell's checker value to string in reverse row order, starting at 6
+        6.times do
+            
+            # Create a hash of each key:value pair of the row corresponding to the counter
+            row_string = @board.layout.select do |cell|
+                @board.layout[cell][:row] == counter
+            end
+           
+            # Add each checker piece or '.' to the string accumulator
+            row_string.each do |cell|
+                if cell[1][:checker] != nil
+                    board_string << " #{cell[1][:checker]} "
+                else
+                    board_string << " . "
+                end
+            end
+            
+            # Add line break to end of string accumulator
+            board_string << "\n"
+
+            counter -= 1
+        end
+        board_string
+    end
+
+    def start
+        # Get total number of user players and request names
+        if get_number_of_players == "1"
+            puts "Player 1: Enter your name"
+            @player1.change_name(get_user_name)
+        else
+            puts "Player 1: Enter your name: "
+            @player1.change_name(get_user_name)
+            puts
+
+            puts "Player 2: Enter your name "
+            @player2.change_name(get_user_name)
+            puts
+        end
+
+        puts print_board
+        puts
+
+        turn = Turn.new(@board, @player1)
+        winner = nil
+        
+        # Play until the board is full or a win condition is made
+        until turn.board_full?
+            turn = Turn.new(@board, @player1)
+            winner = turn.play_turn
+            puts print_board
+            puts
+            break if winner != nil
+    
+            turn = Turn.new(@board, @player2)
+            winner = turn.play_turn
+            puts print_board
+            puts
+            break if winner != nil
+        end
+        
+        #Print the appropriate winner response
+        if winner == nil
+            "The game was a DRAW, how could this have happened??"
+        elsif winner.name == "Computer"
+            "The computer won selecting at random, wow."
+        elsif winner == @player1
+            "Congratulations #{@player1.name}, you win!"
+        else
+            "Congratulations #{@player2.name}, you win!"
+        end
+    end
+
+    def get_number_of_players
+        input = ""
+
+        until input == '1' || input == '2'
+            puts "Please select '1' for single player against computer"
+            puts "                       OR"
+            puts "           Select '2' for two player"
+            puts " _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_"
+            input = gets.chomp
+        end
+        
+        input
+    end
+
+    def get_user_name
+        input = gets.chomp
+        puts "Good luck, #{input}!"
+        puts
+        input
+    end
+end

data/lib/player.rb

@@ -0,0 +1,13 @@
+class Player
+    attr_reader :name,
+                :checker
+
+    def initialize(name, checker)
+        @name = name
+        @checker = checker
+    end
+
+    def change_name(name)
+        @name = name
+    end
+end

data/lib/turn.rb

@@ -0,0 +1,335 @@
+require './lib/board'
+
+class Turn 
+  attr_reader :board, :player
+
+  def initialize(board, player)
+    @board = board
+    @player = player
+  end
+
+  def board_full?
+    full_board = 42
+    @board.layout.each do |cell, attr|
+      if attr[:checker] != nil
+        full_board -= 1
+      else
+        break
+      end
+    end  
+    
+    full_board == 0
+  end
+
+  def random_column
+    columns = ["A", "B", "C", "D", "E", "F", "G"]
+    columns.shuffle!
+
+    while column_full?(columns[0])
+      columns.shift
+    end
+    
+    columns[0]
+  end
+
+  def column_full?(column)
+    columns = ["A", "B", "C", "D", "E", "F", "G"]
+
+    column_cells = @board.layout.select do |cell|
+      @board.layout[cell][:column] == (columns.index(column) + 1) && @board.layout[cell][:checker] == nil
+    end
+
+    column_cells.empty?
+  end
+
+  def lowest_position(column)
+    columns = ["A", "B", "C", "D", "E", "F", "G"]
+
+    column_cells = @board.layout.select do |cell|
+      @board.layout[cell][:column] == (columns.index(column) + 1) && @board.layout[cell][:checker] == nil
+    end
+
+    column_cells.keys[0]
+  end
+
+  def get_input
+    input = ""
+    columns = ["A", "B", "C", "D", "E", "F", "G"]
+
+    until columns.include?(input)
+      puts "✧･ﾟ:* #{@player.name}, Select a Column for your '#{@player.checker}' checker! *:･ﾟ✧"
+      puts "               A - B - C - D - E - F - G"
+      puts
+      input = gets.chomp
+
+      if columns.include?(input) && column_full?(input) == true
+        puts "That column is FULL!"
+        input = ""
+      end
+    end
+
+    input
+  end
+
+  def add_checker(cell)
+    @board.layout[cell][:checker] = @player.checker
+    cell
+  end
+
+  def play_turn
+    if @player.name == "Computer"
+      if check_winner?(add_checker(lowest_position(random_column)))
+        winner = @player
+      end
+    else
+      if check_winner?(add_checker(lowest_position(get_input)))
+        winner = @player
+      end
+    end
+
+    winner
+  end
+
+  def connect_four?(four_cells)
+    checkers = []
+    winner = false
+
+    four_cells.each do |cell|
+      checkers << cell[1][:checker]
+    end
+    
+    if checkers.uniq.size == 1 && !checkers.include?(nil)
+      winner = true
+    end
+
+    winner
+  end
+
+  def winner_row?(checker)
+    row = @board.layout[checker][:row]
+    column = @board.layout[checker][:column]
+
+    #Create a hash of each element in a row
+    row_set = @board.layout.select do |cell| #=> {}
+      @board.layout[cell][:row] == row
+    end
+
+    #Create an array of the sets of four cells in a row
+    sets_of_four = []
+    row_set.each_cons(4) do |set_of_four|
+      sets_of_four << set_of_four
+    end
+
+    #Create an array of the sets of four cells that contain the dropped checker
+    checker_sets = []
+    sets_of_four.each do |checker_set|
+
+      contains_checker = false
+      checker_set.each do |cell|
+        if @board.layout[cell[0]][:column] == column
+          contains_checker = true
+        end
+      end
+
+      if contains_checker
+        checker_sets << checker_set
+      end
+    end
+
+    #Determine if there is a row win condition containing the last checker dropped
+    winner = false
+    checker_sets.each do |set|
+      if connect_four?(set)
+        winner = true
+      end
+    end
+
+    winner
+  end
+
+  def winner_column?(checker)
+    row = @board.layout[checker][:row]
+    column = @board.layout[checker][:column]
+
+    #Create a hash of each element in a column
+    column_set = @board.layout.select do |cell| #=> {}
+      @board.layout[cell][:column] == column
+    end
+
+    #Create an array of the sets of four cells in a column
+    sets_of_four = []
+    column_set.each_cons(4) do |set_of_four|
+      sets_of_four << set_of_four
+    end
+
+    #Create an array of the sets of four cells that contain the dropped checker
+    checker_sets = []
+    sets_of_four.each do |checker_set|
+
+      contains_checker = false
+      checker_set.each do |cell|
+        if @board.layout[cell[0]][:row] == row
+          contains_checker = true
+        end
+      end
+
+      if contains_checker
+        checker_sets << checker_set
+      end
+    end
+
+    #Determine if there is a column win condition containing the last checker dropped
+    winner = false
+    checker_sets.each do |set|
+      if connect_four?(set)
+        winner = true
+      end
+    end
+    
+    winner
+  end
+
+  def winner_down_diag?(checker)
+    row = @board.layout[checker][:row]
+    column = @board.layout[checker][:column]
+    diagonal_keys = [checker]
+
+    columns = ["A", "B", "C", "D", "E", "F", "G"] # <= Consider #Hash implementation
+
+    #Collect upper-left portion of the diagonal set
+    until (row + 1) > 6 || (column - 1) < 1
+      set_cell = (columns[column - 2] + (row + 1).to_s).to_sym
+      diagonal_keys << set_cell
+      row += 1
+      column -= 1
+    end
+    
+    #Resets row and column to starting cell
+    row = @board.layout[checker][:row]
+    column = @board.layout[checker][:column]
+
+    #Collect lower-right portion of the diagonal set
+    until (row - 1) < 1 || (column + 1) > 7
+      set_cell = (columns[column] + (row - 1).to_s).to_sym
+      diagonal_keys << set_cell
+      row -= 1
+      column += 1
+    end
+
+    #Resets row and column to starting cell
+    row = @board.layout[checker][:row]
+    column = @board.layout[checker][:column]
+
+    #Create a hash of each cell, in order, from left => right
+    diagonal_set = {}
+    diagonal_keys.sort.each do |cell|
+      diagonal_set[cell] = @board.layout[cell]
+    end
+
+    #Create an array of the sets of four cells in a diagonal
+    sets_of_four = []
+    diagonal_set.each_cons(4) do |set_of_four|
+      sets_of_four << set_of_four
+    end
+
+    #Create an array of the sets of four cells that contain the dropped checker
+    checker_sets = []
+    sets_of_four.each do |checker_set|
+
+      contains_checker = false
+      checker_set.each do |cell|
+        if @board.layout[cell[0]][:row] == row && @board.layout[cell[0]][:column] == column
+          contains_checker = true
+        end
+      end
+
+      if contains_checker
+        checker_sets << checker_set
+      end
+    end
+
+    #Determine if there is a diagonal down win condition containing the last checker dropped
+    winner = false
+    checker_sets.each do |set|
+      if connect_four?(set)
+        winner = true
+      end
+    end
+    
+    winner
+  end
+
+  def winner_up_diag?(checker)
+    row = @board.layout[checker][:row]
+    column = @board.layout[checker][:column]
+    diagonal_keys = [checker]
+
+    columns = ["A", "B", "C", "D", "E", "F", "G"] # <= Consider #Hash implementation
+
+    #Collect upper-right portion of the diagonal set
+    until (row + 1) > 6 || (column + 1) > 7
+      set_cell = (columns[column] + (row + 1).to_s).to_sym
+      diagonal_keys << set_cell
+      row += 1
+      column += 1
+    end
+    
+    #Resets row and column to starting cell
+    row = @board.layout[checker][:row]
+    column = @board.layout[checker][:column]
+
+    #Collect lower-left portion of the diagonal set
+    until (row - 1) < 1 || (column - 1) < 1
+      set_cell = (columns[column - 2] + (row - 1).to_s).to_sym
+      diagonal_keys << set_cell
+      row -= 1
+      column -= 1
+    end
+
+    #Resets row and column to starting cell
+    row = @board.layout[checker][:row]
+    column = @board.layout[checker][:column]
+
+    #Create a hash of each cell, in order, from left => right
+    diagonal_set = {}
+    diagonal_keys.sort.each do |cell|
+      diagonal_set[cell] = @board.layout[cell]
+    end
+
+    #Create an array of the sets of four cells in a diagonal
+    sets_of_four = []
+    diagonal_set.each_cons(4) do |set_of_four|
+      sets_of_four << set_of_four
+    end
+
+    #Create an array of the sets of four cells that contain the dropped checker
+    checker_sets = []
+    sets_of_four.each do |checker_set|
+
+      contains_checker = false
+      checker_set.each do |cell|
+        if @board.layout[cell[0]][:row] == row && @board.layout[cell[0]][:column] == column
+          contains_checker = true
+        end
+      end
+
+      if contains_checker
+        checker_sets << checker_set
+      end
+    end
+
+    #Determine if there is a diagonal up win condition containing the last checker dropped
+    winner = false
+    checker_sets.each do |set|
+      if connect_four?(set)
+        winner = true
+      end
+    end
+    
+    winner
+  end
+
+  def check_winner?(cell)
+    winner_row?(cell) || winner_column?(cell) || winner_down_diag?(cell) || winner_up_diag?(cell)
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: connect_four_ab_akh
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Adam Bailey
+- Antonio Hunt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+description: 
+email: 
+executables:
+- connect_four_ab_akh
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/connect_four_ab_akh
+- lib/board.rb
+- lib/connect_four_ab_akh.rb
+- lib/game.rb
+- lib/player.rb
+- lib/turn.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Connect Four - 1 or 2 players
+test_files: []