connect_n 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f576942d7bcaf43312e72ace215cb8f92fea00e6f615387151bd2f674c826267
+  data.tar.gz: 947c671cb8af51ca156c2fdd3d58d66dae4c0db3994fd4e82f91e3aa13dbb0b4
+SHA512:
+  metadata.gz: 7ecfb976380fd669a3094a7825e91ed3d312a7ce557c84e6eaca4d2d6b5bfbb67df35357fcfbdfe943ee45b8c1f338f74fc26d01ed5d9c62963ca383e5a43062
+  data.tar.gz: 79c4840a51f839a87a0e8aaa9111e5dc7702628cddfca2c5fb93f255b9b144bd88dfe5f13be2f0ca73121b0fc1a9a49ec5c0a68a62216f06f0d0f48d52ddd089

data/lib/connect_n/board/board.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module ConnectN
+  class Board
+    attr_reader :table, :empty_disc, :cols_amount, :rows_amount
+
+    def initialize(rows_amount: 6, cols_amount: 7, empty_disc: '⚪')
+      @empty_disc = empty_disc
+
+      @rows_amount = rows_amount
+
+      @cols_amount = cols_amount
+
+      @table = Array.new(rows_amount) { Array.new(cols_amount) { empty_disc } }
+    end
+
+    def initialize_copy(original_board)
+      super
+      @empty_disc = @empty_disc.clone
+      @table = @table.clone.map(&:clone)
+    end
+
+    def drop_disc(disc, at_col:)
+      row_num = col_at(at_col).index(empty_disc)
+      row_at(row_num)[at_col] = disc
+      [row_num, at_col, disc]
+    end
+
+    def valid_pick?(pick)
+      valid_col?(pick) and col_at(pick).include?(empty_disc)
+    end
+
+    def filled?
+      !table.flatten.include?(empty_disc)
+    end
+
+    def draw
+      table.each{ |row| draw_border || draw_row(row) }
+      draw_border
+      draw_col_nums
+    end
+
+    def cell_at(row_num, col_num)
+      return unless valid_cell?(row_num, col_num)
+
+      row_at(row_num)[col_num]
+    end
+
+    def cols = table.transpose.map(&:reverse)
+
+    def rows = table
+
+    def col_at(n)
+      return unless valid_col?(n)
+
+      table.transpose[n].reverse
+    end
+
+    def row_at(n)
+      return unless valid_row?(n)
+
+      n = rows_amount - 1 - n
+      table[n]
+    end
+
+    private
+
+    def draw_border
+      cols_amount.times { print '+----' } and puts '+'
+    end
+
+    def draw_row(row)
+      puts '| ' + row.join(' | ') + ' |'
+    end
+
+    def draw_col_nums
+      print '|'
+      (1..cols_amount).each do |num|
+        num.even? ? print(' ') : print('  ')
+        print num
+        num.odd? ? print(' |') : print('  |')
+      end
+      puts
+    end
+
+    def valid_cell?(row_num, col_num) = valid_row?(row_num) && valid_col?(col_num)
+
+    def valid_row?(n) = n.between?(0, rows_amount - 1)
+      
+    def valid_col?(n) = n.between?(0, cols_amount - 1)
+  end
+end

data/lib/connect_n/demo/demo.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative '../player/human_player/human_player'
+require_relative '../player/computer_player/computer_player'
+require_relative '../game/game'
+require_relative '../board/board'
+
+module ConnectN
+  class Demo
+    attr_reader :parameters, :game
+
+    def initialize
+      @parameters = { human_players: [] }
+    end
+
+    def launch
+      if !Game.games('connect_n_saved_games.yaml').empty? && Game.resume?
+        game_name = Game.select_game_name
+        @game = Game.load game_name, 'connect_n_saved_games.yaml'
+        return Game.resume game
+      end
+
+      setup_parameters
+      @game = if parameters[:mode] == 'multiplayer'
+                multiplayer_game
+              else
+                single_player_game
+              end
+      game.play('connect_n_saved_games.yaml')
+    end
+
+    private
+
+    def setup_parameters
+      parameters[:human_players].push [human_name, disc]
+
+      parameters[:cols_amount] = cols_amount
+      parameters[:rows_amount] = rows_amount
+      parameters[:min_to_win] = min_to_win
+
+      parameters[:mode] = mode
+
+      if parameters[:mode] == 'multiplayer'
+        parameters[:human_players].push [human_name => disc]
+      else
+        parameters[:difficulty] = difficulty
+        parameters[:human_starts?] = human_starts?
+      end
+    end
+
+    def cols_amount
+      PROMPT.ask 'How many columns do you want in the board?', convert: :int, default: 7
+    end
+
+    def rows_amount
+      PROMPT.ask 'How many rows do you want in the board?', convert: :int, default: 6
+    end
+
+    def min_to_win
+      PROMPT.ask(
+        'Minimum number of aligned similar discs necessary to win : ',
+        convert: :int,
+        default: 4
+      )
+    end
+
+    def difficulty
+      PROMPT.slider 'Difficulty : ', [*0..10], default: 0
+    end
+
+    def mode
+      PROMPT.select('Choose a game mode : ', ['Single Player', 'Multiplayer']).downcase
+    end
+
+    def human_starts?
+      PROMPT.yes? 'Do you wanna play first?'
+    end
+
+    def disc
+      PROMPT.ask 'Enter a character that will represent your disc : ', default: '🔥' do |q|
+        q.validate(/^.?$/)
+        q.messages[:valid?] = 'Please enter a single character.'
+      end
+    end
+
+    def human_name
+      PROMPT.ask 'Enter your name : ', default: ENV['USER']
+    end
+
+    def multiplayer_game
+      human_players = multiplayer_players
+      board = Board.new(
+        cols_amount: parameters[:cols_amount],
+        rows_amount: parameters[:rows_amount]
+      )
+      Game.new(
+        board: board,
+        first_player: players.first,
+        second_player: players.last,
+        min_to_win: parameters[:min_to_win]
+      )
+    end
+
+    def single_player_game
+      board = Board.new(
+        cols_amount: parameters[:cols_amount],
+        rows_amount: parameters[:rows_amount]
+      )
+      players = single_player_players(board)
+      Game.new(
+        board: board,
+        first_player: players.first,
+        second_player: players.last,
+        min_to_win: parameters[:min_to_win]
+      )
+    end
+
+    def multiplayer_players
+      parameters[:human_players].map do |name, disc|
+        HumanPlayer.new(name: name, disc: disc)
+      end
+    end
+
+    def single_player_players(board)
+      name, disc = parameters[:human_players].first
+      players = [
+        HumanPlayer.new(name: name, disc: disc),
+        ComputerPlayer.new(
+          board: board,
+          opponent_disc: disc,
+          min_to_win: parameters[:min_to_win],
+          difficulty: parameters[:difficulty]
+        )
+      ]
+      parameters[:human_starts?] ? players : players.rotate
+    end
+  end
+end

data/lib/connect_n/game/game.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'tty-box'
+require 'yaml'
+
+require_relative '../player/human_player/human_player'
+require_relative '../player/computer_player/computer_player'
+require_relative '../board/board'
+require_relative '../winnable/winnable'
+
+module ConnectN
+  class Game
+    include Winnable
+
+    attr_reader :board, :players, :min_to_win
+
+    PERMITTED_CLASSES = [Symbol, Game, Board, HumanPlayer, ComputerPlayer]
+
+    def initialize(
+      board:,
+      first_player:,
+      second_player:,
+      min_to_win: 4
+    )
+      @board = board
+      @players = [first_player, second_player]
+      @min_to_win = min_to_win
+    end
+
+    def play(yaml_fn = nil)
+      welcome
+      loop do
+        current_player = players.first
+
+        pick = current_player.pick
+
+        break self.class.save(self, self.class.name_game, yaml_fn) if self.class.save? pick
+
+        next invalid_pick unless board.valid_pick? pick
+
+        row_num, col_num, disc = board.drop_disc(current_player.disc, at_col: pick)
+
+        clear_display
+        board.draw
+
+        break over(current_player) if over?(board, row_num, col_num, disc)
+
+        players.rotate!
+      end
+    end
+
+    def over?(board, row, col, disc) = win?(board, row, col, disc) || board.filled?
+
+    def play_again? = PROMPT.yes? 'Would you like to play again?'
+
+    def self.save?(input) = input == ':w'
+
+    def self.resume? = PROMPT.yes? 'Do you want to resume a game?'
+
+    def self.resume(game) = game.play
+
+    def self.load(name, yaml_fn) = games(yaml_fn)[name.to_sym]
+
+    def self.games(yaml_fn)
+      YAML.safe_load_file(
+        yaml_fn,
+        permitted_classes: PERMITTED_CLASSES,
+        aliases: true
+      ) || {}
+    end
+
+    def self.save(game, name, yaml_fn)
+      games = games(yaml_fn)
+      games[name.to_sym] = game
+      dumped_games = YAML.dump(games)
+      File.write(yaml_fn, dumped_games)
+    end
+
+    def self.name_game = PROMPT.ask 'Name your game : '
+
+    def self.select_game_name(yaml_fn)
+      games = games(yaml_fn).keys.map.with_index(1) { "#{_2} -> #{_1}" }
+      PROMPT.select 'Choose a saved game : ', games, convert: :sym
+    end
+
+    def welcome
+      text = <<~TEXT
+        Welcome to Connect Four
+        #{'    '}
+        To play, Enter a number from 1
+        to #{board.cols_amount}
+        The number corresponds to the
+        column order starting from the
+        left.
+        Enter anything to proceed.
+      TEXT
+      puts TTY::Box.frame text, padding: 2, align: :center
+      board.draw
+    end
+
+    def invalid_pick
+      PROMPT.error 'Invalid Column Number'
+    end
+
+    def over(winner)
+      phrase = board.filled? ? 'It is a tie!' : "#{winner.name} has won!"
+      puts TTY::Box.sucess(phrase)
+    end
+
+    private
+
+    def clear_display
+      puts "\e[1;1H\e[2J"
+    end
+  end
+end

data/lib/connect_n/player/computer_player/computer_player.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative '../player'
+require_relative '../../winnable/winnable'
+
+module ConnectN
+  class ComputerPlayer < Player
+    include Winnable
+
+    attr_accessor :difficulty, :delay
+    attr_reader :opponent_disc, :min_to_win
+
+    def initialize(
+      name: 'Computer',
+      disc: '🧊',
+      min_to_win: 4,
+      difficulty: 0,
+      delay: 0,
+      board:,
+      opponent_disc:
+    )
+      super(name: name, disc: disc)
+      @min_to_win = min_to_win
+      @difficulty = difficulty
+      @delay = delay
+      @board = board
+      @opponent_disc = opponent_disc
+      @scores = { disc => 10000, opponent_disc => -10000 }
+    end
+
+    def pick
+      sleep delay
+      best_score = -Float::INFINITY
+      best_pick = nil
+      @board.cols_amount.times do |pick|
+        next unless @board.valid_pick?(pick)
+
+        board_copy = @board.clone
+        row_num, col_num = board_copy.drop_disc(disc, at_col: pick)
+        score = minimax(board_copy, disc, row_num, col_num)
+        if score >= best_score
+          best_score = score
+          best_pick = pick
+        end
+      end
+      best_pick
+    end
+
+    private
+
+    attr_reader :scores
+
+    def minimax(
+      current_board,
+      current_disc,
+      row_num,
+      col_num,
+      moves_counter = 0,
+      alpha = -Float::INFINITY,
+      beta = Float::INFINITY,
+      depth = difficulty,
+      maximizing: false
+    )
+      return calculate_win_score(current_disc, moves_counter) if win?(current_board, row_num, col_num, current_disc)
+
+      return 0 if current_board.filled?
+
+      return heuristic(current_board, current_disc) if depth <= 0
+
+      if maximizing
+        score = -Float::INFINITY
+        @board.cols_amount.times do |pick|
+          next unless current_board.valid_pick?(pick)
+
+          board_copy = current_board.clone
+          row_num, col_num = board_copy.drop_disc(disc, at_col: pick)
+          score = [
+            score,
+            minimax(board_copy, disc, row_num, col_num, moves_counter + 1, alpha, beta, depth - 1, maximizing: false)
+          ].max
+          break if score >= beta
+
+          alpha = [alpha, score].max
+        end
+      else
+        score = Float::INFINITY
+        @board.cols_amount.times do |pick|
+          next unless current_board.valid_pick?(pick)
+
+          board_copy = current_board.clone
+          row_num, col_num = board_copy.drop_disc(opponent_disc, at_col: pick)
+          score = [
+            score,
+            minimax(board_copy, opponent_disc, row_num, col_num, moves_counter + 1, alpha, beta, depth - 1, maximizing: true)
+          ].min
+          break if score <= alpha
+
+          beta = [beta, score].min
+        end
+      end
+      score
+    end
+
+    def calculate_win_score(disc, moves_counter)
+      score = scores[disc] * @board.cols_amount * @board.rows_amount
+      score / moves_counter.to_f
+    end
+
+    def heuristic(board, disc)
+      value = 0
+      board.rows.each do |row|
+        row.each_cons(min_to_win).each do |set_of_n|
+          disc_count = set_of_n.count disc
+          opponent_disc_count = set_of_n.count opponent_disc
+          next if [disc_count, opponent_disc_count].none?(&:zero?)
+
+          value += disc_count
+          value -= opponent_disc_count
+        end
+      end
+      value
+    end
+  end
+end

data/lib/connect_n/player/human_player/human_player.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'tty-prompt'
+
+require_relative '../player'
+
+module ConnectN
+  class HumanPlayer < Player
+    attr_accessor :save_key
+
+    def initialize(name: 'Human', disc: '🔥', save_key: ':w') 
+      @save_key = save_key
+      super name: name, disc: disc
+    end
+
+    def pick
+      input = PROMPT.ask('Please enter a column number : ')
+      input == save_key ? input : input.to_i - 1
+    end
+  end
+end

data/lib/connect_n/player/player.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ConnectN
+  class Player
+    attr_accessor :name, :disc
+
+    def initialize(name:, disc:)
+      @name = name
+      @disc = disc
+    end
+  end
+end

data/lib/connect_n/prompt/prompt.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'tty-prompt'
+
+module ConnectN
+  PROMPT = TTY::Prompt.new
+end

data/lib/connect_n/winnable/winnable.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ConnectN
+  module Winnable
+    def win?(board, row_num, col_num, disc)
+      return true if vertical_win?(board, row_num, col_num, disc)
+
+      # k = -1 => backward diagonal \
+      # k = 0 => horizontal --
+      # k = 1 => forward diagonal /
+      (-1..1).any? do |k|
+        l = l_discs(board, row_num, col_num, disc, k)
+        r = r_discs(board, row_num, col_num, disc, k)
+        l + r + 1 >= min_to_win
+      end
+    end
+
+    private
+
+    def vertical_win?(board, row_num, col_num, disc)
+      v = v_discs(board, row_num, col_num, disc)
+      v + 1 >= min_to_win
+    end
+
+    # Count similar discs on the left side
+    def l_discs(board, row_num, col_num, disc, k)
+      range = (1...min_to_win)
+      amount = range.find { |i| board.cell_at(row_num - k * i, col_num - i) != disc }
+
+      # amount can be nil if there are more similar discs than min_to_win
+      # in which case it should count as a win
+      amount ||= min_to_win
+
+      # Subtract the dropped disc
+      amount -= 1
+    end
+
+    # Count similar discs on the right side
+    def r_discs(board, row_num, col_num, disc, k)
+      range = (1...min_to_win)
+      amount = range.find { |i| board.cell_at(row_num + k * i, col_num + i) != disc }
+
+      # amount can be nil if there are more similar discs than min_to_win
+      # in which case it should count as a win
+      amount ||= min_to_win
+
+      # Subtract the dropped disc
+      amount -= 1
+    end
+
+    # Count similar discs forming a vertical line
+    def v_discs(board, row_num, col_num, disc)
+      range = (1...min_to_win)
+      amount = range.find do |i|
+        board.cell_at(row_num - i, col_num) != disc
+      end
+
+      # amount can be nil if there are more similar discs than min_to_win
+      # in which case it should count as a win
+      amount ||= min_to_win
+      
+      # Subtract the dropped disc
+      amount -= 1
+    end
+  end
+end

data/lib/connect_n.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'connect_n/prompt/prompt'
+require_relative 'connect_n/player/human_player/human_player'
+require_relative 'connect_n/player/computer_player/computer_player'
+require_relative 'connect_n/demo/demo'
+require_relative 'connect_n/game/game'
+require_relative 'connect_n/board/board'
+
+module ConnectN; end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: connect_n
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Lhoussaine (Jee-El) Ghallou
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-01-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.23.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.23.1
+- !ruby/object:Gem::Dependency
+  name: tty-box
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+description: A more general version of connect-4 where you try to connect N similar
+  discs. It comes with several features and a friendly API that allows you to customize
+  the game however you want!
+email: ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/connect_n.rb
+- lib/connect_n/board/board.rb
+- lib/connect_n/demo/demo.rb
+- lib/connect_n/game/game.rb
+- lib/connect_n/player/computer_player/computer_player.rb
+- lib/connect_n/player/human_player/human_player.rb
+- lib/connect_n/player/player.rb
+- lib/connect_n/prompt/prompt.rb
+- lib/connect_n/winnable/winnable.rb
+homepage: https://rubygems.org/gems/connect_n
+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.1
+signing_key:
+specification_version: 4
+summary: Connect-N!
+test_files: []