connect_4_2307_nick_joop 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 712c64859e2aca132163b360976f53340762dda3a965207d4efd99fa299c7779
+  data.tar.gz: 563da52410152fb429a607d9ed745bf80c049f4aab155240b84922af41766ec9
+SHA512:
+  metadata.gz: 07da7340c19e38a0f557f4923626f98e8a57b6a34038daa79128cfab2c9b4bd3b7b5924660f0fe83cf25b61be89227ed927b4ca1380c209032911c5f91c2ee5f
+  data.tar.gz: 70ea227a35e4a63244fb5630284a74a53822e53198ce720d425d9d2e5000d692fde671f30d6ebaef81df084bb0173cf7cec1aa7cab20e85f44b95c42cf771d6a

data/bin/connect_4_graphics

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+require 'ruby2d'
+require 'require_helper'
+
+set width: 775
+set height: 800
+passed_menu = false
+
+# cordinate data for rendering blank squares, as well as X's and O's when placed
+# symbols correspond to the return from Player.place_piece and TurnManager.cpu_turn
+cordinates =  {
+  A5: [50, 700], A4: [50, 600], A3: [50, 500], A2: [50, 400], A1: [50, 300], A0: [50, 200],
+  B5: [150, 700], B4: [150, 600], B3: [150, 500], B2: [150, 400], B1: [150, 300], B0: [150, 200],
+  C5: [250, 700], C4: [250, 600], C3: [250, 500], C2: [250, 400], C1: [250, 300], C0: [250, 200],
+  D5: [350, 700], D4: [350, 600], D3: [350, 500], D2: [350, 400], D1: [350, 300], D0: [350, 200],
+  E5: [450, 700], E4: [450, 600], E3: [450, 500], E2: [450, 400], E1: [450, 300], E0: [450, 200],
+  F5: [550, 700], F4: [550, 600], F3: [550, 500], F2: [550, 400], F1: [550, 300], F0: [550, 200],
+  G5: [650, 700], G4: [650, 600], G3: [650, 500], G2: [650, 400], G1: [650, 300], G0: [650, 200]
+
+}
+
+def set_up_game_manager
+  board = Board.new
+  board.setup_game
+  player_1 = Player.new("X")
+  cpu = ComputerSmart.new(player_1.type)
+  TurnManager.new(board, player_1, cpu)
+end
+
+game = set_up_game_manager
+
+# Uses cordinates Hash to render blank square positions representing connect 4 board
+def render_game(cordinates, board)
+  set title: "Connect 4"
+  set background: "blue"
+  cordinates.each do |key, values|
+    Square.new(
+      x: values[0], y: values[1],
+      size: 85,
+      color: 'white', opacity: 1,
+      z: 0
+    )
+  end
+end
+
+# Helper method returns the corresponding symbol for selected column to drop token
+def find_column(event)
+  return :A if event.x > 0 && event.x <= 140
+  return :B if event.x > 140 && event.x <= 240
+  return :C if event.x > 240 && event.x <= 340
+  return :D if event.x > 340 && event.x <= 440
+  return :E if event.x > 440 && event.x <= 540
+  return :F if event.x > 540 && event.x <= 640
+  return :G if event.x > 640 && event.x <= 800
+end
+
+# method gathers cordinates token is placed at, and uses cordinates hash to render
+# token in the correct placement
+def render_token(cords, type, cordinates)
+  Text.new(
+    "#{type}",
+    x: cordinates[cords][0] + 5, y: cordinates[cords][1] -10,
+    style: 'bold',
+    size: 85,
+    color: 'red'
+  )
+end
+
+# Images used for showing a game over message on screen
+def render_game_over
+  Text.new(
+    "Game Over",
+    x: 125, y: 0,
+    style: 'bold',
+    size: 100,
+    color: 'red'
+  )
+  Text.new(
+    "press p to play again, or q to quit",
+    x: 130, y: 125,
+    size: 35,
+    color: 'red'
+  )
+end
+
+# key down and mouse down methods for game selection and token position selection
+on :key_down do |event|
+  if event.key == "p"
+    clear
+    game.reset_game
+    render_game(cordinates, game.board)
+    passed_menu = true
+  end
+  if event.key == "q"
+    close
+  end
+end
+
+on :mouse_down do |event|
+  if passed_menu
+    checker = CheckerCriteria.new
+    column = find_column(event)
+    token_placement = game.board.place_piece(column, game.player.type)
+    if !(token_placement == "invalid column, column full")
+      render_token(token_placement, game.player.type, cordinates)
+      cpu_token = game.cpu_turn
+      render_token(cpu_token, game.cpu.type, cordinates)
+      game.board.render_board
+      if checker.check_win_conditions(game.board) || game.board.draw?
+        game.board.clear_board
+        game.board.setup_game
+        render_game_over
+        passed_menu = false
+      end
+    end
+  end
+end
+# key down and mouse down methods for game selection and token position selection
+
+# set up the first start screen with p to play and q to quit options
+def render_start_screen
+  Text.new(
+    "Welcome to connect 4",
+    x: 125, y: 325,
+    style: 'bold',
+    size: 50,
+    color: 'red'
+  )
+  Text.new(
+    "press p to play again, or q to quit",
+    x: 130, y: 475,
+    size: 35,
+    color: 'red'
+  )
+end
+
+render_start_screen
+# set up the first start screen with p to play and q to quit options
+
+show

data/bin/connect_4_runner

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require 'require_helper'
+
+board = Board.new
+game = GameManager.new
+game.start_game(board)

data/lib/board.rb

@@ -0,0 +1,98 @@
+require_relative 'token'
+
+class Board
+  attr_reader :header, :columns
+  attr_accessor :play_area
+
+  def initialize
+    @play_area = {
+      A: [],
+      B: [],
+      C: [],
+      D: [],
+      E: [],
+      F: [],
+      G: []
+    }
+    @columns = @play_area.keys
+  end
+
+  def setup_game
+    @play_area.values.each do |column|
+      6.times {column.append(Token.new)}
+    end
+  end
+
+  def read_cell(column, row)
+    row -= 1
+    @play_area[column][row].type
+  end
+
+  def render_board
+    puts @play_area.keys.join
+    board_array = @play_area.values.transpose
+    rows = board_array.map {|row| row.map {|token| token.type}}
+    rows.each {|line| puts line.join}
+  end
+
+  def clear_board
+    initialize
+  end
+
+  def place_piece(column, piece_type)
+    return "invalid column" if !@columns.include?(column)
+    i = -1
+    loop do
+      if @play_area[column][i].type == "."
+        @play_area[column][i].type = piece_type
+        cord = "#{column}#{i+6}"
+        return cord.intern
+      end
+      i -= 1
+      return "invalid column, column full" if i < -6
+    end
+  end
+
+  def draw? #allways call win condition test first
+    all_tokens = @play_area.values.flatten
+    return false if all_tokens.any? {|token| token.type == "."}
+    true
+  end
+
+  def set_draw_test
+    @play_area.each {|k,v| v.each {|token| token.type = "X"}}
+  end
+    # test if render_board outputs correct rows/columns
+  # by comparing to manually setting rows/columns
+  # def render_board_manual
+  #   puts @play_area.keys.join
+  #   i = 0
+  #   rows = 5
+  #   until i > rows do
+  #     row = form_row(i)
+  #     puts row
+  #     i += 1
+  #   end
+  # end
+
+  # def form_row(num)
+  #   [@play_area[:A][num].type, @play_area[:B][num].type, 
+  #   @play_area[:C][num].type, @play_area[:D][num].type, 
+  #   @play_area[:E][num].type, @play_area[:F][num].type, 
+  #   @play_area[:G][num].type].join
+  # end
+
+  # def token_positions_by_type(type)
+  #   counter = 0
+  #   single_array =[]
+  #   until counter == 7
+  #   @play_area[@columns[counter]].select.with_index do |point, index| 
+  #     if point.type == type
+  #       single_array << "#{@columns[counter].to_s}#{index}"
+  #     end #if
+  #     end #do
+  #     counter += 1
+  #   end #until
+  #   single_array
+  # end #def
+end

data/lib/checker_criteria.rb

@@ -0,0 +1,110 @@
+class CheckerCriteria
+  attr_reader :win, :winner
+
+  def initialize
+    @win = false
+    @winner = nil
+    @positive_diagonals = [["A5", "B4", "C3", "D2"], 
+    ["A4", "B3", "C2", "D1"], 
+    ["A3", "B2", "C1", "D0"], 
+    ["B5", "C4", "D3", "E2"], 
+    ["B4", "C3", "D2", "E1"], 
+    ["B3", "C2", "D1", "E0"], 
+    ["C5", "D4", "E3", "F2"], 
+    ["C4", "D3", "E2", "F1"], 
+    ["C3", "D2", "E1", "F0"], 
+    ["D5", "E4", "F3", "G2"], 
+    ["D4", "E3", "F2", "G1"], 
+    ["D3", "E2", "F1", "G0"]]
+
+    @negative_diagonals = 
+    [["D5", "C4", "B3", "A2"],
+    ["D4", "C3", "B2", "A1"],
+    ["D3", "C2", "B1", "A0"],
+    ["E5", "D4", "C3", "B2"],
+    ["E4", "D3", "C2", "B1"],
+    ["E3", "D2", "C1", "B0"],
+    ["F5", "E4", "D3", "C2"],
+    ["F4", "E3", "D2", "C1"],
+    ["F3", "E2", "D1", "C0"],
+    ["G5", "F4", "E3", "D2"],
+    ["G4", "F3", "E2", "D1"],
+    ["G3", "F2", "E1", "D0"]]
+    
+    @columns = [:A, :B, :C, :D, :E, :F, :G]
+  end
+
+  def check_win_conditions(board)
+    check_vertical_win(board) || check_horizontal_win(board) || test_for_diagonal_wins(board)
+  end
+
+  #Private
+  
+  def token_positions_by_type(type, board)
+    counter = 0
+    single_array =[]
+    until counter == 7
+    board.play_area[@columns[counter]].select.with_index do |point, index| 
+      if point.type == type
+        single_array << "#{@columns[counter].to_s}#{index}"
+      end #if
+      end #do
+      counter += 1
+    end #until
+    single_array
+  end #def
+
+  def test_for_diagonal_wins(board)
+    @positive_diagonals.each do |win| if (win - token_positions_by_type("X", board)).empty?
+      @win = true
+      @winner = "X"
+      end
+    end
+    @negative_diagonals.each do |win| if (win - token_positions_by_type("X", board)).empty?
+      @win = true
+      @winner = "X"
+      end
+    end
+    @positive_diagonals.each do |win| if (win - token_positions_by_type("O", board)).empty?
+      @win = true
+      @winner = "O"
+      end
+    end
+    @negative_diagonals.each do |win| if (win - token_positions_by_type("O", board)).empty?
+      @win = true
+      @winner = "O"
+      end
+    end
+    @win
+  end
+
+  def check_vertical_win(board)
+    vert_strings = board.play_area.values.map do |column|
+      column.map {|token| token.type}
+    end
+    vert_wins = vert_strings.map {|col| col.join}
+    if vert_wins.any? { |str| str.include?("XXXX") }
+      @winner = "X"
+      @win = true  
+    elsif vert_wins.any? { |str| str.include?("OOOO") }
+      @winner = "O"
+      @win = true  
+    end
+  end
+
+  def check_horizontal_win(board)
+    horizontal_strings = board.play_area.values.transpose.map do |row|
+      row.map {|token| token.type}
+    end
+    horizontal_wins = horizontal_strings.map {|row| row.join}
+    if horizontal_wins.any? {|str| str.include?("XXXX")} 
+      @winner = "X"
+      @win = true  
+    elsif horizontal_wins.any? {|str| str.include?("OOOO")} 
+      @winner = "O"
+      @win = true  
+    end
+  end
+end
+
+

data/lib/computer_random.rb

@@ -0,0 +1,16 @@
+class ComputerRandom
+  attr_reader :type, :enemy
+  def initialize(enemy_type = "X")
+    @type = OPPONENT[enemy_type]
+    @enemy = enemy_type
+  end
+
+  OPPONENT = {"O"=>"X", "X"=>"O"}
+  COLUMNS = [:A, :B, :C, :D, :E, :F, :G]
+
+  def place_piece(board)
+    board.place_piece(COLUMNS[rand(0..6)], @type)
+  end
+end
+
+

data/lib/computer_smart.rb

@@ -0,0 +1,83 @@
+class ComputerSmart
+  attr_reader :type, :enemy, :main_connected_tokens, :placement_column
+
+  def initialize(type = "X") #default needs to be removed eventually
+    @type = OPPONENT[type]
+    @enemy = type
+    @main_connected_tokens = 0
+    @placement_column = nil
+    @blocking = false
+  end
+
+  OPPONENT = {"O"=>"X", "X"=>"O"}
+  COLUMNS_SYM = [:A, :B, :C, :D, :E, :F, :G]
+  WEIGHTED_RANDOM = [:A, :A, :B, :B, :C, :C, :C, :C, :D, :D, :D, :E, :E, :E, :E, :F, :F, :G, :G]
+
+  def place_piece(board)
+    @main_connected_tokens = 0
+    tester(board, @enemy, false)
+    tester(board, @type, true)
+    case @main_connected_tokens
+    when 2..6
+      board.place_piece(COLUMNS_SYM[@placement_column], @type)
+    else
+      board.place_piece(WEIGHTED_RANDOM[rand(0..18)], @type)
+    end
+  end
+
+# Private
+
+  def tester(board, type_checker, blocking)
+    [*0..6].each do |column_number| 
+      compass_tester(column_number, board, 1, -1, type_checker, blocking) #checks positive diagonal
+      compass_tester(column_number, board, -1, -1, type_checker, blocking) #checks negative diagonal
+      compass_tester(column_number, board, 1, 0, type_checker, blocking) #checks horizontal
+      compass_tester(column_number, board, 0, -1, type_checker, blocking) #checks vertical
+    end
+  end
+
+  def compass_tester(column_number, board, array_number_num, item_number_num, type_checker, block)
+    connected_tokens = 0
+    array_number = column_number 
+    item_number = find_empty(column_number, board)
+    rev_array_number = column_number 
+    rev_item_number = find_empty(column_number, board)
+    loop do
+      array_number += array_number_num
+      item_number += item_number_num
+      break if array_number > 6 || array_number < 0
+      break if item_number > 5 || item_number < 0
+      break if board.play_area[COLUMNS_SYM[array_number]][item_number].type == "."
+      break if board.play_area[COLUMNS_SYM[array_number]][item_number].type == type_checker
+      connected_tokens += 1
+    end
+    loop do
+      rev_array_number += array_number_num * -1
+      rev_item_number += item_number_num * -1
+      break if rev_array_number > 6 || rev_array_number < 0
+      break if rev_item_number > 5 || rev_item_number < 0
+      break if board.play_area[COLUMNS_SYM[rev_array_number]][rev_item_number].type == "."
+      break if board.play_area[COLUMNS_SYM[rev_array_number]][rev_item_number].type == type_checker
+      connected_tokens += 1
+    end
+    if connected_tokens > @main_connected_tokens && find_empty(column_number, board) < 6
+      @main_connected_tokens = connected_tokens 
+      @placement_column = column_number
+      @blocking = block
+    end
+  end
+
+  def find_empty(column_number, board)
+    vertical_position = 5
+    previous = 6
+    loop do
+      if board.play_area[COLUMNS_SYM[column_number]][vertical_position].type == "."
+        return previous = vertical_position
+      end
+      vertical_position -= 1
+      break if vertical_position <= -1
+    end
+    previous
+  end
+
+end

data/lib/game_manager.rb

@@ -0,0 +1,78 @@
+require_relative 'require_helper'
+
+class GameManager 
+
+  def start_game(board)
+    puts "Welcome to CONNECT FOUR"
+    puts "Enter p to play. Enter q to quit"
+    choice = gets.chomp
+  
+    if choice.downcase == "p"
+      selection = ''
+      player_1 = x_or_o
+      cpu = select_cpu_type(player_1)
+      board.setup_game
+      game = TurnManager.new(board, player_1, cpu)
+      game_loop(board, game, cpu)
+    elsif choice.downcase == "q"
+      return false
+    else
+      puts "Invalid choice"
+      start_game(board)
+    end
+  end
+
+  def game_loop(board, game, cpu)
+    checker = CheckerCriteria.new
+    loop do
+      game.start_turn
+      break if check_re_render(board, checker)
+      game.cpu_turn
+      break if check_re_render(board, checker)
+      if board.draw?
+        puts "It's a draw"
+        board.render_board
+        board.clear_board
+        break
+      end
+    end
+    start_game(board)
+  end
+
+  def select_cpu_type(player)
+    puts "s for smart computer, r for random computer"
+      choice = gets.chomp
+      if choice == 's'
+        cpu = ComputerSmart.new(player.type)
+      elsif choice == 'r'
+        cpu = ComputerRandom.new(player.type)
+      else
+        puts "invalid selection"
+        select_cpu_type(player)
+      end
+  end
+
+  def check_re_render(board, checker)
+    if checker.check_win_conditions(board)
+      board.render_board
+      board.clear_board
+      puts "Game Over: #{checker.winner} wins"
+      return true
+    end
+    false
+  end
+
+  def x_or_o
+    puts "would you like X's or O's?('x/o')"
+    selection = gets.chomp
+    if selection == "x"
+      return player = Player.new("X")
+    elsif selection == "o"
+      return player = Player.new("O")
+    else
+      puts "invalid selecton"
+      x_or_o
+    end
+  end
+  
+end

data/lib/player.rb

@@ -0,0 +1,19 @@
+class Player
+  attr_reader :type
+  def initialize(type)
+    @type = find_type(type)
+  end
+
+  def find_type(type)
+    case type
+    when 2, "x", "X"
+      "X"
+    when 1, "o", "O", 0
+      "O"
+    end
+  end
+
+  def place_piece(column, board)
+    board.place_piece(column, @type)
+  end
+end

data/lib/require_helper.rb

@@ -0,0 +1,8 @@
+require_relative 'board'
+require_relative 'token'
+require_relative 'player'
+require_relative 'turn_manager'
+require_relative 'computer_random'
+require_relative 'checker_criteria'
+require_relative 'game_manager.rb'
+require_relative 'computer_smart'

data/lib/token.rb

@@ -0,0 +1,7 @@
+class Token
+  attr_accessor :type
+
+  def initialize
+    @type = "."
+  end
+end

data/lib/turn_manager.rb

@@ -0,0 +1,43 @@
+class TurnManager
+  attr_reader :board, :player, :cpu
+  def initialize(board, player, cpu)
+    @board = board
+    @player = player
+    @cpu = cpu
+  end
+
+  def start_turn
+    @board.render_board
+    puts "Select a column for your piece(A-G)"
+    column = gets.chomp.upcase.intern
+    new_token = @player.place_piece(column, @board)
+    check_column(new_token)
+  end
+
+  def check_column(new_token)
+    if new_token == "invalid column, column full" || new_token == "invalid column"
+      until new_token != "invalid column, column full" && new_token != "invalid column"
+        puts "#{new_token}"
+        puts "Select another row(A-G)"
+        column = gets.chomp.upcase.intern
+        new_token = @player.place_piece(column, @board)
+      end
+    end
+  end
+
+  # method for cpu turn here
+  def cpu_turn
+    new_token = @cpu.place_piece(@board)
+    if new_token == "invalid column, column full" || new_token == "invalid column"
+      until new_token != "invalid column, column full" && new_token != "invalid column"
+        new_token = @cpu.place_piece(@board)
+      end
+    end
+    new_token
+  end
+
+  def reset_game
+    @board.clear_board
+    @board.setup_game
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: connect_4_2307_nick_joop
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Nick Spencer
+- Joop Stark
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-07-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby2d
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description: Connect 4, play either CLI or graphic interface vs computer
+email:
+- strangebrew202@gmail.com
+- stark.joop@gmail.com
+executables:
+- connect_4_graphics
+- connect_4_runner
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/connect_4_graphics
+- bin/connect_4_runner
+- lib/board.rb
+- lib/checker_criteria.rb
+- lib/computer_random.rb
+- lib/computer_smart.rb
+- lib/game_manager.rb
+- lib/player.rb
+- lib/require_helper.rb
+- lib/token.rb
+- lib/turn_manager.rb
+homepage:
+licenses:
+- MIT
+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.3.26
+signing_key:
+specification_version: 4
+summary: Connect 4 game
+test_files: []