connect_four_ab-akh 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 96eea4eeb42f21b2dbea427824d2ce49a156df72b9c7f9f2cb0b84b4d3615561
+  data.tar.gz: 6ed98f45a0eeb05f3bf4251bba3d5726fe060e6836a8bafd19bd5f1773a945fe
+SHA512:
+  metadata.gz: a46c6b7ff8487cb2f2d56249de2fa9fb48541537e03bf34b668d1f8be39ee38bab28d8c2cfcdcf2d6692117c6b996c5a33d11ec55b5026520e079837126352d7
+  data.tar.gz: 1e43f3970dcc3c4b3093f8f58bbe3c05f20290615fe3e3e3587eb628494bdd9e5c34359b35d5f8f74b11d8e46116fac13a7d3605c29b15ec4299e5121d9f2402

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/connect_four_ab-akh/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/game.rb

@@ -0,0 +1,79 @@
+class Game
+    attr_reader :board,
+                :player,
+                :computer
+
+    def initialize
+        @board = Board.new
+        @player = Player.new("Player", "X")
+        @computer = Player.new("Computer", "O")
+    end
+
+    def start
+        puts welcome_user
+        puts print_board
+    end
+
+    def welcome_user
+       "Welcome to CONNECT FOUR"
+    end
+
+    def print_board
+        # Create board string accumulator 
+        board_string = "ABCDEFG\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
+            #require "pry"; binding.pry
+            # 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
+        puts print_board
+
+        turn = Turn.new(@board, @player)
+        winner = nil
+    
+        until turn.board_full?
+            turn = Turn.new(@board, @player)
+            winner = turn.play_turn
+            puts print_board
+            puts
+            break if winner != nil
+    
+            turn = Turn.new(@board, @computer)
+            winner = turn.play_turn
+            puts print_board
+            puts
+            break if winner != nil
+        end
+        
+        if winner == @player
+            puts "Congratulations #{@player.name}, you win!"
+        elsif winner == @computer
+            puts "Sorry #{@player.name}, you lose!"
+        else
+            "The game was a DRAW, you couldn't beat a computer choosing at random"
+        end
+    end
+end

data/lib/connect_four_ab-akh/player.rb

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

data/lib/connect_four_ab-akh/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 "✧･ﾟ:* Select A Column *:･ﾟ✧"
+      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

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

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: connect_four_ab-akh
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+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/connect_four_ab-akh.rb
+- lib/connect_four_ab-akh/board.rb
+- lib/connect_four_ab-akh/game.rb
+- lib/connect_four_ab-akh/player.rb
+- lib/connect_four_ab-akh/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: []