connect_cuatro 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07ff3f60ceb45977060c65c2589af0eafd766e1730ce122d53f3bcdde980b3ef
-  data.tar.gz: 3f5fc98c83e067b825386028088218edbba01b4b42c88a4fb61204205e2e180c
+  metadata.gz: d32f7b0ef5a218571b39947d24d9ed600e68b89820be801790ca8ae70f9d8c79
+  data.tar.gz: 577496c0635027112f11e0cf06797475c549ce258f6cb79a645cb88e889d7805
 SHA512:
-  metadata.gz: f930ad3eacd2bf8f7312905ec7fc77b4721543ea238077593ec51a1b863a1aa402e4150cc37c35929b13a93c99fa73c2acfc39dafa5d8b11e4fd06fc3dab11d6
-  data.tar.gz: d7efd9647459774b052e88dccab13f207f819b1a290da20820ae55ba10da155a99ce9f65b426d0914e820be6c8754ca5e938f641db6faef6ba28cae4839848ab
+  metadata.gz: af2e17e8e65cd9f16f942fd341a2a7b513ca049cea105771845a3c8b844d6451ae60d0ece75b33506d862effd3e3f59015803ae9c4c39e957e7b4079d02f5a6c
+  data.tar.gz: 55d87d9d5eeee647b8f813dbe3e7af31c32a8da43ef64ccccc1f09a216c4e08b3a9edce92a3d11dd7e85ddcd114e0c305201d90be1e9c5e6c30c2b3ffe58f871

data/lib/board.rb

@@ -1,101 +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
+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
+        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.26
+      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

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

data/lib/connect_four.rb

@@ -1,90 +1,85 @@
-# 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
+# frozen_string_literal: true
+require_relative "game_engine"
+require_relative "multiplayer_game_engine"
+require_relative "msg"
+require_relative "ip_config"
+
+class ConnectFour
+  include IpConfig
+  include MSG
+
+  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
+    elsif game_mode == "2P"
+      @game_engine = MPGameEngine.new
+    else
+      puts INPUT_ERR_MSG(game_mode)
+      set_game_engine
+    end
+    start
+  end
+
+  def start
+    loiter if @game_engine.instance_of?(MPGameEngine)
+    @game_engine.play_game
+    main_menu
+  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, "X")
+    @game_engine.player2 = Player.new(foe, "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

@@ -1,99 +1,98 @@
-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
+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] == "."
+      true
+    else
+      false
+    end
+  end
+
+  # returns player object and increments queue
+  def whose_turn
+    plyr = @current_player
+    @current_player = if plyr == @players[0]
+      @players[1]
+    else
+      @players[0]
+    end
+    plyr
+  end
+
+  def drop_token(column, token)
+    @board.drop_token(column, token)
+  end
+end
+
+# session = GameEngine.new
+# session.main_menu

data/lib/ip_config.rb

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

data/lib/msg.rb

@@ -1,52 +1,51 @@
-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
+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!"
+
+  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

@@ -1,149 +1,142 @@
-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
+require_relative "board"
+require_relative "player"
+require_relative "msg"
+require_relative "cli"
+require_relative "ip_config"
+
+class MPGameEngine
+  include IpConfig
+  include MSG
+
+  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 = players.find { |player| player.name == p1 }
+  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
+                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
+              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)
+    Board::COLUMNS.include?(column) && @board.board[0][idx] == "."
+  end
+
+  # returns player object and increments queue
+  def whose_turn
+    plyr = @current_player
+    @current_player = if plyr == players[0]
+      players[1]
+    else
+      players[0]
+    end
+    plyr
+  end
+
+  def drop_token(column, token)
+    @board.drop_token(column, token)
+  end
+end

data/lib/player.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: connect_cuatro
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Matt Darlington
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-14 00:00:00.000000000 Z
+date: 2023-09-16 00:00:00.000000000 Z
 dependencies: []
 description: Digital version of the Classic Connect Four boardgame.
 email: