connect_cuatro 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 07ff3f60ceb45977060c65c2589af0eafd766e1730ce122d53f3bcdde980b3ef
+  data.tar.gz: 3f5fc98c83e067b825386028088218edbba01b4b42c88a4fb61204205e2e180c
+SHA512:
+  metadata.gz: f930ad3eacd2bf8f7312905ec7fc77b4721543ea238077593ec51a1b863a1aa402e4150cc37c35929b13a93c99fa73c2acfc39dafa5d8b11e4fd06fc3dab11d6
+  data.tar.gz: d7efd9647459774b052e88dccab13f207f819b1a290da20820ae55ba10da155a99ce9f65b426d0914e820be6c8754ca5e938f641db6faef6ba28cae4839848ab

data/bin/connect_cuatro

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'connect_four'
+
+ConnectFour.new.main_menu

data/lib/board.rb

@@ -0,0 +1,101 @@
+class Board
+  attr_reader :board
+
+  def initialize(rows = 6, columns = 7)
+    # board 'height'
+    @num_rows = rows
+    # board 'width'
+    @num_columns = columns
+    # Initialize an empty board filled with '.'
+    @board = Array.new(@num_rows) { Array.new(@num_columns, '.') }
+  end
+
+  # return x, y coordinates
+  def drop_token(column, token)
+    col_idx = column_to_index(column)
+    row_idx = @num_rows - 1
+    @board.reverse_each do |row|
+      if row[col_idx] == "."
+        # animate dropping of token before return
+        self.animate_token(col_idx, row_idx, token)
+        row[col_idx] = token
+        return col_idx, row_idx
+      end
+      row_idx -= 1
+    end
+  end
+
+  def animate_token(col_idx, row_idx, token)
+    row_idx.times do |i|
+      sleep 0.77
+      CLI.clear
+      @board.each_with_index do |row, idx|
+        pseudo_row = row.dup
+        if idx == i
+          pseudo_row[col_idx] = token
+          puts pseudo_row.join(' ')
+        else
+          puts row.join(' ')
+        end
+      end
+      # Print column numbers for easier reference
+      puts COLUMNS[0...@num_columns].join(' ')
+    end
+    sleep 0.77
+    CLI.clear
+  end
+
+  def display
+    # Loop through each row and print it
+    @board.each do |row|
+      puts row.join(' ')
+    end
+    # Print column numbers for easier reference
+    puts COLUMNS[0...@num_columns].join(' ')
+  end
+
+  def column_to_index(column)
+    COLUMNS.index(column)
+  end
+
+  def board_full?
+    !@board.flatten.include?(".")
+  end
+
+  def check_win(column, row, token)
+    DIRECTIONS.each do |dx, dy|
+      count = 1  # Start with the token just placed
+
+      # Check one direction
+      count += check_direction(column, row, dx, dy, token)
+      # Check the opposite direction
+      count += check_direction(column, row, -dx, -dy, token)
+
+      return true if count >= 4  # Four or more in a row
+    end
+    false
+  end
+
+  def check_direction(column, row, dx, dy, token)
+    count = 0
+    x, y = column + dx, row - dy
+
+    while y.between?(0, @num_rows - 1) && x.between?(0, @num_columns - 1) && @board[y][x] == token
+      count += 1
+      x += dx
+      y -= dy
+    end
+
+    count
+  end
+
+
+  COLUMNS = %w{A B C D E F G}
+
+  DIRECTIONS = [
+    [0, 1],  # Horizontal
+    [1, 0],  # Vertical
+    [1, 1],  # Diagonal right
+    [1, -1]  # Diagonal left
+  ]
+end

data/lib/cli.rb

@@ -0,0 +1,9 @@
+module CLI
+  def self.get_input
+    STDIN.gets.chomp.upcase
+  end
+
+  def self.clear
+    system('clear')
+  end
+end

data/lib/connect_four.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+require_relative 'game_engine'
+require_relative 'multiplayer_game_engine'
+require_relative 'msg'
+require_relative 'ip_config'
+
+class ConnectFour
+  include MSG, IP_CONFIG
+
+  attr_reader :game_engine
+
+  def initialize
+    @game_engine = nil
+  end
+
+  def main_menu
+    puts WELCOME_MSG
+    play_quit = CLI.get_input
+    # play_quit = "P" # testing
+    if play_quit == "Q"
+      abort(BYE_MSG)
+    elsif play_quit == "P"
+      puts PLAY_MSG
+      set_game_engine
+    else
+      puts P_OR_Q_ERR_MSG
+      main_menu
+    end
+  end
+
+  #returns game engine MP or SP
+  def set_game_engine
+    puts ONEPLAYER_TWOPLAYER
+    game_mode = CLI.get_input
+    # game_mode = "2P" # testing
+    if game_mode == "1P"
+      @game_engine = GameEngine.new
+      self.start
+    elsif game_mode == "2P"
+      @game_engine = MPGameEngine.new
+      self.start
+    else
+      puts INPUT_ERR_MSG(game_mode)
+      set_game_engine
+    end
+  end
+
+  def start
+    if @game_engine.class == MPGameEngine
+      self.loiter  # wait in lobby
+      @game_engine.play_game
+      self.main_menu
+    else
+      @game_engine.play_game
+      self.main_menu
+    end
+  end
+
+  def loiter
+    # make initial curl request
+    username = ENV['USER']
+    foe = ""
+    p1 = ""
+    # send /init request
+    response = `curl -s "#{P2P_IP}/init?player=#{username}"`.chomp # => '...patient'
+    until response == "start"
+      print WAITING_MSG
+      # send /start request; if game ready to start, will return foe
+      response = `curl -s "#{P2P_IP}/start?player=#{username}"`.chomp
+      if response.include?("start")
+        start_responses = response.split(" ")
+        foe = start_responses[1]
+        p1 = start_responses[2]  # p1 used to set @current_player
+        response = "start"
+        break
+      end
+      LOADER_MSG(7)  # wait 7 seconds
+    end
+
+    puts ""
+    puts OPP_FOUND
+    @game_engine.player1 = Player.new(username, token = "X")
+    @game_engine.player2 = Player.new(foe, token = "O")
+    @game_engine.set_current_player(p1)
+    print "game ready to start"
+    LOADER_MSG(3)  # wait 3 seconds
+  end
+end
+
+# ConnectFour.new.main_menu

data/lib/game_engine.rb

@@ -0,0 +1,99 @@
+require_relative 'board'
+require_relative 'player'
+require_relative 'msg'
+require_relative 'cli'
+
+class GameEngine
+  include MSG
+
+  attr_reader :player1,
+              :ai,
+              :players,
+              :current_player,
+              :board,
+              :piece_count
+
+  def initialize
+    @player1 = Player.new(ENV['USER'], "X")
+    @ai = Player.new("HAL", "O")
+    @players = [@player1, @ai]
+    @board = Board.new
+    @current_player = @players[0]
+  end
+
+  def play_game  # Player has hit 'p'
+    game_over = false
+    until game_over
+      puts @board.display
+      # keep false until valid input => in-range, un-filled column
+      turn_over = false
+      plyr = whose_turn
+      token_x, token_y = nil, nil # returned from #drop_token and passed to #win_condition
+      # if human player
+      if plyr == @player1
+        # force user to enter valid input
+        until turn_over
+          # only runs once (right after opponent takes turn)
+          puts PLAYER_TURN_MSG
+          column = CLI.get_input
+          if valid_input(column)
+            token_x, token_y = drop_token(column, plyr.token)
+            turn_over = true
+          else
+            # continue to run until HUMAN user enters valid input
+            puts INPUT_ERR_MSG(column)
+          end
+        end
+      else
+        # computer's turn
+        # TODO trash talk
+        # keep false until computer picks unfilled column (idx always in-range)
+        until turn_over
+          column = Board::COLUMNS.sample
+          if valid_input(column)
+            token_x, token_y = drop_token(column, plyr.token)
+            turn_over = true
+          end
+        end
+      end
+      if @board.check_win(token_x, token_y, plyr.token)
+        puts @board.display
+        puts "#{VICTORY_MSG(plyr.name)}"
+        game_over = true
+      end
+      if @board.board_full?
+        puts @board.display
+        puts TIE_GAME_MSG
+        game_over = true
+      end
+    end
+  end
+
+  def valid_input(column)
+    idx = @board.column_to_index(column)
+    if Board::COLUMNS.include?(column) && @board.board[0][idx] == '.'
+      return true
+    else
+      return false
+    end
+  end
+
+  # returns player object and increments queue
+  def whose_turn
+    plyr = @current_player
+    if plyr == @players[0]
+      @current_player = @players[1]
+    else
+      @current_player = @players[0]
+    end
+    return plyr
+  end
+
+  def drop_token(column, token)
+    idx = @board.column_to_index(column)
+    @board.drop_token(column, token)
+  end
+end
+
+# session = GameEngine.new
+# session.main_menu

data/lib/ip_config.rb

@@ -0,0 +1,4 @@
+module IP_CONFIG
+  P2P_IP = '52.53.215.135:3333'
+  TEST_IP = 'localhost:3333'
+end

data/lib/msg.rb

@@ -0,0 +1,52 @@
+module MSG
+  ONEPLAYER_TWOPLAYER = "1P || 2P"
+
+  WELCOME_MSG = "Let's play **** CONNECT FOUR ****
+  Connect four of your checkers in a row while preventing your opponent from doing the same.\n
+  press 'p' to play; 'q' to quit:"
+
+  PLAY_MSG = "#{ENV["USER"]} says we're playing Connect Four!!"
+
+  BYE_MSG = "Sucka’s only see what’s in front of them while real game playa’s see the whole board, – 777\nDeuces!"
+
+  MP_BYE_MSG = "If you want to play again, rerun the script. Goodbye!"
+
+  P_OR_Q_ERR_MSG = "Sorry, I didn't understand that selection. press 'p' to play; 'q' to quit:"
+
+  PLAYER_TURN_MSG = "Choose where you want to drop your token"
+
+  TIE_GAME_MSG = "The board is full!! It's a draw!"
+
+  WAITING_MSG = "Waiting for opponent to join"
+
+  OPP_FOUND = "Opponent found...establishing connection"
+
+  def TIMES_UP_MSG(column)
+    "Time's up: you randomly chose column #{column}"
+  end
+  def WAITING_FOR_PLYR_MSG(plyr_name)
+    "Waiting for #{plyr_name} to make a move"
+  end
+
+  def LOADER_MSG(i)
+    i.times do
+      sleep 1.6
+      print " . "
+    end
+    puts ""
+  end
+
+  def VICTORY_MSG(plyr_name)
+    if plyr_name == "HAL"
+      "HAL won!! You just lost to an unliving being!! Boom!!"
+    else
+      "#Hot Dog, we have a Winner! Congratulations #{plyr_name}!!!"
+    end
+  end
+
+  def INPUT_ERR_MSG(input)
+    "#{input} is an invalid selection"
+  end
+
+  # X_OR_O_MSG = "Pick your piece! X or O??"
+end

data/lib/multiplayer_game_engine.rb

@@ -0,0 +1,149 @@
+require_relative 'board'
+require_relative 'player'
+require_relative 'msg'
+require_relative 'cli'
+require_relative 'ip_config'
+require 'thread'
+
+class MPGameEngine
+  include MSG, IP_CONFIG
+
+  attr_reader :board
+  attr_accessor :player1,
+                :player2,
+                :current_player
+
+  def initialize
+    @player1 = nil
+    @player2 = nil
+    @current_player = nil
+    @board = Board.new
+  end
+
+  def players
+    [@player1, @player2]
+  end
+
+  def set_current_player(p1)
+    @current_player = self.players.filter { |player| player.name == p1 }.first
+  end
+
+  def play_game  # Player has hit 'p'
+    game_over = false
+    until game_over
+      puts @board.display
+      turn_over = false
+      plyr = whose_turn
+      token_x, token_y = nil, nil # returned from #drop_token and passed to #win_condition
+      # local client
+      if plyr == @player1
+        input_received = false
+        column = nil
+        mutex = Mutex.new
+
+        input_thread = Thread.new do
+          puts PLAYER_TURN_MSG
+          # keep false until valid input => in-range, un-filled column
+          until turn_over
+            ready = IO.select([STDIN], nil, nil, 1.6)  # 4th arg is 'release after time' (s)
+
+            if ready
+              column = STDIN.gets.chomp.upcase
+              if valid_input(column)
+                mutex.synchronize do
+                  input_received = true
+                  turn_over = true
+                  column = column
+                end
+              else
+                puts INPUT_ERR_MSG(column)
+                # continue to run until local client enters valid input
+                # loops back to until turn_over
+              end
+            end
+          end
+        end
+
+        timer_thread = Thread.new do
+          10.times do |i|
+            print "#{10 - i }. . "
+            sleep 1.6
+            break if mutex.synchronize { input_received }
+          end
+          # if the player doesn't select a column, random valid selection will occur
+          until turn_over
+            column = Board::COLUMNS.sample
+            if valid_input(column)
+              puts TIMES_UP_MSG(column)
+              mutex.synchronize do
+                input_received = true
+                turn_over = true
+                column = column
+              end
+            end
+          end
+        end
+
+        [input_thread, timer_thread].each(&:join)
+
+        token_x, token_y = drop_token(column, plyr.token)
+        # send valid column selection to server
+        `curl -s "#{P2P_IP}/move?player=#{plyr.name}?column=#{column}"`
+      else  # remote client || @player2
+        until turn_over
+          11.times do
+            puts WAITING_FOR_PLYR_MSG(plyr.name)
+            response = `curl -s "#{P2P_IP}/status?player=#{@player1.name}"`.chomp
+            # require 'pry'; binding.pry
+            unless response.include?("patience")  # unless this fails => response == <valid letter>
+              token_x, token_y = drop_token(response, plyr.token)
+              turn_over = true
+              break
+            end
+            sleep 1.6
+          end
+        end
+      end
+
+      if @board.check_win(token_x, token_y, plyr.token)
+        puts @board.display
+        puts "#{VICTORY_MSG(plyr.name)}"
+        game_over = true
+      end
+
+      if @board.board_full?
+        puts @board.display
+        puts TIE_GAME_MSG
+        game_over = true
+      end
+    end
+    sleep 1.6
+    # send /reset command to server to clear out stored variables
+    `curl -s "#{P2P_IP}/reset"`
+  end
+
+  def valid_input(column)
+    idx = @board.column_to_index(column)
+    if Board::COLUMNS.include?(column) && @board.board[0][idx] == '.'
+      true
+    else
+      false
+    end
+  end
+
+  # returns player object and increments queue
+  def whose_turn
+    plyr = @current_player
+    if plyr == players[0]
+      @current_player = players[1]
+    else
+      @current_player = players[0]
+    end
+    plyr
+  end
+
+  def drop_token(column, token)
+    idx = @board.column_to_index(column)
+    @board.drop_token(column, token)
+  end
+end

data/lib/player.rb

@@ -0,0 +1,9 @@
+class Player
+  attr_reader :name
+  attr_accessor :token
+  
+  def initialize(name, token="X")
+    @name = name
+    @token = token
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: connect_cuatro
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Matt Darlington
+- Taylor Pubins
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-09-14 00:00:00.000000000 Z
+dependencies: []
+description: Digital version of the Classic Connect Four boardgame.
+email:
+- matthewsdarlington@gmail.com
+- tpubz@icloud.com
+executables:
+- connect_cuatro
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/connect_cuatro
+- lib/board.rb
+- lib/cli.rb
+- lib/connect_four.rb
+- lib/game_engine.rb
+- lib/ip_config.rb
+- lib/msg.rb
+- lib/multiplayer_game_engine.rb
+- lib/player.rb
+homepage: http://rubygems.org/gems/connect_cuatro
+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.4.19
+signing_key:
+specification_version: 4
+summary: Connect Four -- Turing School of Software & Design -- Mod1 Project
+test_files: []