ttt-cli 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fb849f2253377ff35938474e78c77feedaff258619d0236495c01174a87876e9
+  data.tar.gz: 72987ee85da5b4888d03b09136720baa956fa0c53a5a7639fdeb6d65f0380cf7
+SHA512:
+  metadata.gz: 9b20b7ec55fefb1b92bcaeb1233dca660b7c9a36f2a495ccffdf3bcafdd9012295bcc582c5e98f7987a1c004c40334012ce71b1381b2b033ebc320515a123322
+  data.tar.gz: 2c472ce566f303a26ace4fc4bc09118353b3d255dbcc92f6663286d2639acc3878585e60e0c7dd7e9550bf9dcf48b944f1a9132ef14fedb8af40f73e713ec48e

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 dionixs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,45 @@
+# Tic-Tac-Toe
+
+Консольная реализация игры: "**Крестики-нолики**".
+
+![](https://raw.githubusercontent.com/dionixs/ttt-cli/master/image.png)
+
+Особенности: 
+
+- 3 игровых режима: **Single-player**, **Hot-seat**, **Observer**.
+- 3 уровня сложности.
+- **Непобедимый AI** на уровне сложности **Hard**.
+
+- **Emoji** в качестве игровых символов.
+- Счётчик побед и поражений.
+
+## Установка
+
+Установка пакета  `tty-cli` из [Rubygems](https://rubygems.org/gems/ttt-cli):
+
+```
+$> gem install ttt-cli
+```
+
+## Запуск
+
+```bash
+$> ttt-cli
+```
+
+## Тесты
+
+```bash
+$> bundle exec rake spec
+```
+
+## Ресурсы
+
+* [Крестики-нолики](https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B5%D1%81%D1%82%D0%B8%D0%BA%D0%B8-%D0%BD%D0%BE%D0%BB%D0%B8%D0%BA%D0%B8)
+* [Let's build the classic game using object-orientation](https://www.vikingcodeschool.com/professional-development-with-ruby/tic-tac-toe)
+* [Tic Tac Toe: Understanding the Minimax Algorithm](https://www.neverstopbuilding.com/blog/minimax)
+* [Как написать бота, которого будет нельзя обыграть в «крестики-нолики»](https://tproger.ru/translations/tic-tac-toe-minimax/)
+
+## License
+
+Code released under [MIT](https://github.com/dionixs/ttt-cli/blob/master/LICENSE) license.

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'ttt/cli'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bin/ttt-cli

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# encoding: utf-8
+
+require 'ttt-cli'
+
+# Cтарт новой игры:
+# - Выводим приветственный текст
+# - Устанавливаем режим игры
+# - Устанавливаем уровень сложности игры
+# - Устанавливаем символы игрокам
+# - Определяем кто ходит первым
+# - Выводим игровое поле на экран
+game = Game.start
+
+# основной цикл:
+# -- пока поле не заполнилось или один из игроков не победил
+loop do
+  # ход текущего игрока
+  game.current_player.make_move(game.board)
+  # вывод игрового поля на экран
+  CommandLine::Display.print_board(game.board)
+
+  # проверка ситуации на поле
+  if game.over?
+    # вывод сообщения о победе/ничье.
+    game.over_message
+    # спрашиваем игрока, хочет ли он сыграть еще
+    if game.start_new_game?
+      # создаем новую игру
+      game = Game.start
+      next
+    else
+      exit
+    end
+  end
+
+  # переключение на следующего игрока
+  game.switch_player
+end

data/lib/ttt-cli.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'ttt-cli/version'
+require_relative 'ttt-cli/emoji'
+require_relative 'ttt-cli/display'
+require_relative 'ttt-cli/board'
+require_relative 'ttt-cli/ai'
+require_relative 'ttt-cli/strategies/random_ai'
+require_relative 'ttt-cli/strategies/medium_ai'
+require_relative 'ttt-cli/strategies/hard_ai'
+require_relative 'ttt-cli/player'
+require_relative 'ttt-cli/players/computer'
+require_relative 'ttt-cli/players/human'
+require_relative 'ttt-cli/judge'
+require_relative 'ttt-cli/engine'
+require_relative 'ttt-cli/game'

data/lib/ttt-cli/ai.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+class AI
+  attr_accessor :best_move
+
+  def self.create(game, type, computer)
+    type.new(game, computer)
+  end
+
+  def initialize(game, computer)
+    @game = game
+    @board = game.board
+    @computer = computer
+    @enemy = @game.first_player
+    @best_move = nil
+  end
+
+  # Метод для генерации хода AI
+  def move_generate; end
+
+  private
+
+  def is_first_move?
+    @board.empty_cells.size == 9 ||
+      @board.empty_cells.size == 8
+  end
+
+  # основная минимакс-функция
+  # возвращает значение, если найдено конечное состояние(+10, 0, -10)
+  # проходит по всем пустым клеткам на поле
+  # вызывает минимакс функцию для каждой из них (рекурсия)
+  # оценивает полученные значения
+  # и возвращает наилучшее из них
+  def minimax(board, player, depth = 0, moves = {})
+    # копия доски
+    new_board = board.dup
+    # индексы свободных клеток
+    empty_indices = new_board.empty_cells
+
+    # проверка на терминальное состояние
+    return 10 - depth if @game.won?(@computer)
+    return -10 + depth if @game.won?(@enemy)
+    return 0 if @game.draw?
+
+    empty_indices.each do |index|
+      new_board.fill_cell(index, player.token)
+      next_player = opponent(player)
+      moves[index] = minimax(new_board, next_player, depth + 1)
+      new_board.reset_cell(index)
+    end
+
+    # возвращаем наилучшее значение
+    minimax_score(moves, player)
+  end
+
+  # метод для оценки полученных значений
+  # возвращает наилучшее значение
+  def minimax_score(moves, player)
+    if player.token == @computer.token
+      @best_move, best_score = moves.max_by { |_, v| v }
+    else
+      @best_move, best_score = moves.min_by { |_, v| v }
+    end
+
+    best_score
+  end
+
+  # метод для выбора оппонента для текущего игрока
+  def opponent(player)
+    if player.token == @computer.token
+      @enemy
+    else
+      @computer
+    end
+  end
+end

data/lib/ttt-cli/board.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+
+# Класс Board - игровое поле.
+#
+# По умолчанию имеет размер 3х3.
+class Board
+  attr_accessor :cells
+  attr_reader :game
+
+  include Emoji
+
+  def initialize(game)
+    @cells = Array.new(9, DASH)
+    @game = game
+  end
+
+  # метод для заполнения клетки
+  def fill_cell(index, token)
+    @cells[index] = token
+  end
+
+  # метод для проверки клетки на занятость
+  def cell_taken?(index)
+    @cells[index] == X || @cells[index] == O
+  end
+
+  # метод для проверки всех клеток на занятость
+  def full?
+    @cells.all? do |char|
+      if char == X || char == O
+        true
+      else
+        false
+      end
+    end
+  end
+
+  # метод возвращает массив индексов пустых клеток доски
+  def empty_cells
+    @cells.filter_map.with_index do |cell, index|
+      index if cell != X && cell != O
+    end
+  end
+
+  # метод возвращает массив четных индексов клеток доски
+  def even_cells
+    empty_cells.filter(&:even?)
+  end
+
+  # метод для очистки клетки
+  def reset_cell(index)
+    @cells[index] = DASH
+  end
+
+  def to_s
+    Rainbow("
+        |      |
+    #{@cells[0]}  |  #{@cells[1]}  |  #{@cells[2]}
+  ______|______|______
+        |      |
+    #{@cells[3]}  |  #{@cells[4]}  |  #{@cells[5]}
+  ______|______|______
+        |      |
+    #{@cells[6]}  |  #{@cells[7]}  |  #{@cells[8]}
+        |      |
+").lawngreen
+  end
+end

data/lib/ttt-cli/display.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+require 'tty-prompt'
+require 'tty-table'
+
+module CommandLine
+  class Display
+    def self.prompt
+      TTY::Prompt.new(interrupt: :exit)
+    end
+
+    def self.welcome_banner
+      clear
+      puts Rainbow("Welcome to Tic Tac Toe!\n").lawngreen
+    end
+
+    def self.clear
+      system('clear') || system('cls')
+    end
+
+    def self.difficulty
+      levels = %w[easy medium hard]
+      prompt.select(
+        'Select a difficulty level:',
+        levels, symbols: { marker: '>' }
+      )
+    end
+
+    def self.game_mode
+      modes = %w[singleplayer hotseat observer]
+      prompt.select(
+        'Choose game mode:',
+        modes, symbols: { marker: '>' }
+      )
+    end
+
+    def self.user_token(tokens = %w[X O])
+      prompt.select(
+        'Do you want to be X or O?',
+        tokens, symbols: { marker: '>' }
+      )
+    end
+
+    def self.choose_cell(choice = nil)
+      moves = Array(1..9).map(&:to_s)
+      while !moves.include?(choice) && choice != 'exit'
+        print Rainbow('What is your move? (1-9): ').lawngreen
+        choice = STDIN.gets.strip
+      end
+      exit if choice == 'exit'
+      choice.to_i - 1
+    end
+
+    def self.winner(game)
+      if game.game_mode == :singleplayer
+        puts Rainbow("\tYou Win!\n").deepskyblue
+      else
+        puts Rainbow("#{game.current_player.name} has won the game!\n").deepskyblue
+      end
+    end
+
+    def self.draw
+      puts Rainbow("\tDraw!\n").yellow
+    end
+
+    def self.play_again
+      prompt.yes?('Would you to play again?')
+    end
+
+    def self.loser(game)
+      if game.game_mode == :singleplayer
+        puts Rainbow("\tYou Lose!\n").red
+      else
+        winner(game)
+      end
+    end
+
+    def self.logo
+      "
+    ┌───────────────┐
+    │  Tic-Tac-Toe  │
+    └───────────────┘"
+    end
+
+    def self.scoreboard(game)
+      table = TTY::Table.new [game.first_player.name, '  Tie  ', game.second_player.name],
+                             [[game.wins, game.draws, game.losses]]
+      scoreboard = table.render :unicode, alignment: [:center]
+      puts Rainbow(scoreboard).lawngreen
+      puts
+    end
+
+    def self.print_board(board)
+      clear
+      puts Rainbow(logo).lawngreen
+      puts board
+      scoreboard(board.game)
+    end
+  end
+end

data/lib/ttt-cli/emoji.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Emoji
+  DASH = "\u2796"
+  X = "\u274C"
+  O = "\u2B55\uFE0F"
+end

data/lib/ttt-cli/engine.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+class Engine
+  attr_accessor :difficulty
+
+  @@game_mode = :singleplayer
+
+  @@draws = 0
+  @@wins = 0
+  @@losses = 0
+
+  include Emoji
+
+  DIFFICULTY_LEVELS = {
+    easy: RandomAI,
+    medium: MediumAI,
+    hard: HardAI
+  }.freeze
+
+  def self.set_game_mode(mode) # todo
+    if Engine.is_singleplayer?(mode)
+      Engine.reset_counters if @@game_mode == :hotseat || @@game_mode == :observer
+      @@game_mode = :singleplayer
+    elsif mode == :hotseat
+      Engine.reset_counters if @@game_mode == :singleplayer || @@game_mode == :observer
+      @@game_mode = :hotseat
+    else
+      Engine.reset_counters if @@game_mode == :singleplayer || @@game_mode == :hotseat
+      @@game_mode = :observer
+    end
+  end
+
+  def self.is_singleplayer?(mode)
+    mode == :singleplayer
+  end
+
+  def self.set_difficulty
+    if @@game_mode == :singleplayer
+      Engine.difficulty_level
+    else
+      HardAI
+    end
+  end
+
+  def self.game_mode
+    mode = CommandLine::Display.game_mode
+    mode.to_sym
+  end
+
+  def self.difficulty_level
+    level = CommandLine::Display.difficulty
+    DIFFICULTY_LEVELS[level.to_sym]
+  end
+
+  def self.reset_counters
+    @@draws = 0
+    @@losses = 0
+    @@wins = 0
+  end
+
+  def game_mode
+    @@game_mode
+  end
+
+  def wins
+    @@wins
+  end
+
+  def draws
+    @@draws
+  end
+
+  def losses
+    @@losses
+  end
+end

data/lib/ttt-cli/game.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+# Класс Game: Управляет игровым процессом
+class Game < Engine
+  attr_accessor :first_player, :second_player,
+                :current_player, :judge
+  attr_reader :board
+
+  def self.start
+    CommandLine::Display.welcome_banner
+    Game.set_game_mode(Game.game_mode)
+    new_game = new(Game.set_difficulty)
+    Game.setup_game(new_game)
+  end
+
+  def self.setup_game(game)
+    game.update_players!
+    game.set_players_tokens(game.get_user_token)
+    game.who_goes_first
+    CommandLine::Display.print_board(game.board)
+    game
+  end
+
+  def initialize(difficulty = MediumAI)
+    @board = Board.new(self)
+    @difficulty = difficulty
+    @first_player = Players::Human.new(token: X)
+    @second_player = Players::Computer.new(token: O, game: self)
+    @current_player = @first_player
+    @judge = Judge.new(self)
+  end
+
+  def start_new_game?
+    CommandLine::Display.play_again
+  end
+
+  def update_players!
+    if @@game_mode == :singleplayer
+      singleplayer_mode
+    elsif @@game_mode == :hotseat
+      hotseat_mode
+    else
+      observer_mode
+    end
+  end
+
+  def singleplayer_mode
+    @second_player = Players::Computer.new(token: O, game: self)
+  end
+
+  def hotseat_mode
+    @first_player = Players::Human.new(token: X, name: 'Player 1')
+    @second_player = Players::Human.new(token: O, name: 'Player 2')
+    @current_player = @first_player
+  end
+
+  def observer_mode
+    @first_player = Players::Computer.new(token: X, name: 'Connor', game: self)
+    @second_player = Players::Computer.new(token: O, name: 'William', game: self)
+    @current_player = @first_player
+  end
+
+  def get_user_token
+    if @@game_mode == :singleplayer
+      CommandLine::Display.user_token
+    end
+  end
+
+  # Метод который устанавливает символы игрокам
+  # По умолчанию игрок - X, компьютер - O
+  def set_players_tokens(token)
+    if @@game_mode == :singleplayer
+      if token != 'X'
+        @first_player.token = O
+        @second_player.token = X
+      end
+    end
+  end
+
+  # Метод для выбора игрока, который будет ходить первым.
+  # По умолчанию первым ходит игрок.
+  def who_goes_first
+    case @first_player.token
+    when O
+      @current_player = @second_player
+    end
+  end
+
+  # Метод для переключения на следующего игрока
+  def switch_player
+    case @current_player
+    when @first_player
+      @current_player = @second_player
+    else
+      @current_player = @first_player
+    end
+  end
+
+  def over?
+    draw? || won?
+  end
+
+  def draw?
+    @board.full? && !won?
+  end
+
+  def won?(player = @current_player)
+    @judge.is_combo?(player)
+  end
+
+  def over_message
+    increase_counter
+    CommandLine::Display.print_board(@board)
+    print_winner
+  end
+
+  # Метод для объявления победителя
+  def print_winner
+    if draw?
+      CommandLine::Display.draw
+    elsif won?(@first_player)
+      CommandLine::Display.winner(self)
+    elsif won?(@second_player)
+      CommandLine::Display.loser(self)
+    end
+  end
+
+  def increase_counter
+    if draw?
+      @@draws += 1
+    elsif won?(@first_player)
+      @@wins += 1
+    elsif won?(@second_player)
+      @@losses += 1
+    end
+  end
+end

data/lib/ttt-cli/judge.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Класс Judge - судья (проверщик).
+class Judge
+  attr_accessor :board
+
+  WIN_COMBINATIONS = [
+    [0, 1, 2], [3, 4, 5], [6, 7, 8],
+    [0, 3, 6], [1, 4, 7], [2, 5, 8],
+    [0, 4, 8], [2, 4, 6]
+  ].freeze
+
+  def initialize(game)
+    @board = game.board.cells
+  end
+
+  # основной метод для проверки на выигрыш
+  # возвращает true если обнаружена выигрышная комбинация
+  def is_combo?(player)
+    !winning_combination(player.token).nil?
+  end
+
+  private
+
+  # метод который возвращает первую подходящую комбинацию
+  # или nil если не было совпадения
+  def winning_combination(token)
+    WIN_COMBINATIONS.find do |indices|
+      # возвращаем значения для соответствующих индексов
+      # values_at(*[0,1,2]) => values_at(0,1,2)
+      values = @board.values_at(*indices)
+      # проверяем, равны ли все значения X или O
+      values.all?(token)
+    end
+  end
+end

data/lib/ttt-cli/player.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Класс Player (abstract class)
+class Player
+  attr_accessor :board, :token, :name, :enemy
+
+  include Emoji
+
+  def initialize(params)
+    @name = params[:name]
+    @token = params[:token]
+  end
+
+  def make_move(board); end
+
+  def position; end
+end

data/lib/ttt-cli/players/computer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Players
+  class Computer < Player
+    attr_reader :difficulty
+
+    def initialize(params)
+      super(params)
+      @name = 'Computer' unless params[:name]
+      @game = params[:game]
+      @board = @game.board
+      @enemy = @game.first_player unless params[:enemy]
+      @difficulty = @game.difficulty
+      @ai = AI.create(@game, @difficulty, self)
+    end
+
+    def make_move(board)
+      move = position
+      sleep 0.6
+      board.fill_cell(move, @token) unless board.cell_taken?(move)
+    end
+
+    private
+
+    def position
+      @ai.move_generate
+    end
+  end
+end

data/lib/ttt-cli/players/human.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Players
+  class Human < Player
+    def initialize(params)
+      super(params)
+      @name = 'Human' unless params[:name]
+    end
+
+    def make_move(board)
+      move = position
+      if !board.cell_taken?(move)
+        board.fill_cell(move, @token)
+      else
+        make_move(board)
+      end
+    end
+
+    private
+
+    def position
+      CommandLine::Display.choose_cell
+    end
+  end
+end

data/lib/ttt-cli/strategies/hard_ai.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class HardAI < AI
+  def move_generate
+    if is_first_move?
+      @board.even_cells.sample
+    else
+      minimax(@board, @computer)
+      @best_move
+    end
+  end
+end

data/lib/ttt-cli/strategies/medium_ai.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class MediumAI < AI
+  def move_generate
+    if is_first_move?
+      @board.empty_cells.sample
+    else
+      minimax(@board, @computer)
+      @best_move
+    end
+  end
+end

data/lib/ttt-cli/strategies/random_ai.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class RandomAI < AI
+  def move_generate
+    @board.empty_cells.sample
+  end
+end

data/lib/ttt-cli/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TttCli
+  VERSION = '0.1.4'
+end

data/spec/ai_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'ttt-cli'
+
+include Emoji
+
+describe AI do
+  before { @game = Game.new }
+
+  it 'should create RandomAI' do
+    ai = AI.create(@game, RandomAI, @game.second_player)
+    expect(ai.class).to eq RandomAI
+  end
+
+  it 'should create MediumAI' do
+    ai = AI.create(@game, MediumAI, @game.second_player)
+    expect(ai.class).to eq MediumAI
+  end
+
+  it 'should create HardAI' do
+    ai = AI.create(@game, HardAI, @game.second_player)
+    expect(ai.class).to eq HardAI
+  end
+
+  it 'move RandomAI' do
+    ai = AI.create(@game, RandomAI, @game.second_player)
+    move = ai.move_generate
+    expect(move.between?(0, 8)).to eq true
+  end
+
+  it 'move MediumAI' do
+    ai = AI.create(@game, MediumAI, @game.second_player)
+    move = ai.move_generate
+    expect(move.between?(0, 8)).to eq true
+  end
+
+  it 'move HardAI' do
+    ai = AI.create(@game, HardAI, @game.second_player)
+    move = ai.move_generate
+    expect(move.between?(0, 8)).to eq true
+  end
+end

data/spec/board_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'ttt-cli'
+
+include Emoji
+
+describe Board do
+  before { @game = Game.new }
+
+  it 'fill cell' do
+    @game.board.fill_cell(0, X)
+    expect(@game.board.cells[0]).to eq X
+  end
+
+  it 'check taken cell' do
+    @game.board.fill_cell(0, X)
+    expect(@game.board.cell_taken?(0)).to eq true
+  end
+
+  it 'occupied cells' do
+    @game.board.cells = [X, O, X, X, X, O, O, X, O]
+    expect(@game.board.full?).to eq true
+  end
+
+  it 'should empty cells' do
+    @game.board.fill_cell(0, X)
+    expect(@game.board.empty_cells.size).to eq 8
+  end
+
+  it 'should even cells' do
+    expect(@game.board.even_cells.size).to eq 5
+  end
+
+  it 'should emty cell' do
+    @game.board.fill_cell(0, X)
+    expect(@game.board.reset_cell(0)).to eq DASH
+  end
+end

data/spec/game_spec.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'ttt-cli'
+
+include Emoji
+
+describe Game do
+  it 'singleplayer game mode' do
+    Game.set_game_mode(:singleplayer)
+    game = Game.new
+    expect(game.game_mode).to eq :singleplayer
+  end
+
+  it 'hotseat game mode' do
+    Game.set_game_mode(:hotseat)
+    game = Game.new
+    expect(game.game_mode).to eq :hotseat
+  end
+
+  it 'observer game mode' do
+    Game.set_game_mode(:observer)
+    game = Game.new
+    expect(game.game_mode).to eq :observer
+  end
+
+  it 'players for singleplayer mode' do
+    Game.set_game_mode(:singleplayer)
+    game = Game.new
+    game.update_players!
+
+    first_player = game.first_player.class
+    second_player = game.second_player.class
+    current_player = game.current_player.class
+
+    expect(first_player).to eq Players::Human
+    expect(second_player).to eq Players::Computer
+    expect(current_player).to eq Players::Human
+  end
+
+  it 'players for hotseat mode' do
+    Game.set_game_mode(:hotseat)
+    game = Game.new
+    game.update_players!
+
+    first_player = game.first_player.class
+    second_player = game.second_player.class
+    current_player = game.current_player.class
+
+    expect(first_player).to eq Players::Human
+    expect(second_player).to eq Players::Human
+    expect(current_player).to eq Players::Human
+  end
+
+  it 'players for observer mode' do
+    Game.set_game_mode(:observer)
+    game = Game.new
+    game.update_players!
+
+    first_player = game.first_player.class
+    second_player = game.second_player.class
+    current_player = game.current_player.class
+
+    expect(first_player).to eq Players::Computer
+    expect(second_player).to eq Players::Computer
+    expect(current_player).to eq Players::Computer
+  end
+
+  it 'easy level' do
+    Game.set_game_mode(:singleplayer)
+    game = Game.new(RandomAI)
+    expect(game.difficulty).to eq RandomAI
+  end
+
+  it 'medium level' do
+    Game.set_game_mode(:singleplayer)
+    game = Game.new(MediumAI)
+    expect(game.difficulty).to eq MediumAI
+  end
+
+  it 'hard level' do
+    Game.set_game_mode(:singleplayer)
+    game = Game.new(HardAI)
+    expect(game.difficulty).to eq HardAI
+  end
+
+  it 'human goes first' do
+    Game.set_game_mode(:singleplayer)
+    game = Game.new(HardAI)
+    game.update_players!
+    game.set_players_tokens('X')
+    game.who_goes_first
+    expect(game.current_player.token).to eq game.first_player.token
+  end
+
+  it 'computer goes first' do
+    Game.set_game_mode(:singleplayer)
+    game = Game.new(HardAI)
+    game.update_players!
+    game.set_players_tokens('O')
+    game.who_goes_first
+    expect(game.current_player.token).to eq game.second_player.token
+  end
+
+  it 'switch players' do
+    Game.set_game_mode(:singleplayer)
+
+    game = Game.new(RandomAI)
+    first_player = Players::Computer.new(token: X, game: game)
+    game.first_player = first_player
+    game.current_player = first_player
+
+    # проверка переключения игроков
+    2.times do
+      game.current_player.make_move(game.board)
+      game.switch_player
+    end
+
+    expect(game.current_player.token).to eq X
+  end
+
+  it 'check draw' do
+    Game.set_game_mode(:singleplayer)
+    game = Game.new(RandomAI)
+
+    cell = [X, O, X, X, X, O, O, X, O]
+    game.board.cells = cell
+
+    expect(game.draw?).to eq true
+  end
+
+  it 'check win' do
+    Game.set_game_mode(:singleplayer)
+    game = Game.new(RandomAI)
+
+    cell = [X, O, O, X, O, O, X, X, X]
+    game.board.cells = cell
+    game.judge.board = cell
+
+    expect(game.won?).to eq true
+  end
+
+  it 'check counter win' do
+    Game.set_game_mode(:singleplayer)
+    game = Game.new(RandomAI)
+
+    cell = [X, O, O, X, O, O, X, X, X]
+    game.board.cells = cell
+    game.judge.board = cell
+
+    10.times { game.increase_counter }
+    expect(game.wins).to eq 10
+  end
+
+  it 'check counter draws' do
+    Game.set_game_mode(:singleplayer)
+    game = Game.new(RandomAI)
+
+    cell = [X, O, X, X, X, O, O, X, O]
+    game.board.cells = cell
+
+    5.times { game.increase_counter }
+    expect(game.draws).to eq 5
+  end
+
+  it 'check counter losses' do
+    Game.set_game_mode(:singleplayer)
+    game = Game.new(RandomAI)
+
+    cell = [X, DASH, X, DASH, X, DASH, O, O, O]
+    game.board.cells = cell
+    game.judge.board = cell
+
+    8.times { game.increase_counter }
+    expect(game.losses).to eq 8
+  end
+end

data/spec/judge_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'ttt-cli'
+
+include Emoji
+
+describe Judge do
+  before { @game = Game.new }
+
+  it 'combo check' do
+    board = [X, O, DASH, DASH, X, DASH, DASH, O, X]
+    @game.board.cells = board
+    @game.judge.board = board
+
+    player = @game.current_player
+    expect(@game.judge.is_combo?(player)).to eq true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+  #   # This allows you to limit a spec run to individual examples or groups
+  #   # you care about by tagging them with `:focus` metadata. When nothing
+  #   # is tagged with `:focus`, all examples get run. RSpec also provides
+  #   # aliases for `it`, `describe`, and `context` that include `:focus`
+  #   # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  #   config.filter_run_when_matching :focus
+  #
+  #   # Allows RSpec to persist some state between runs in order to support
+  #   # the `--only-failures` and `--next-failure` CLI options. We recommend
+  #   # you configure your source control system to ignore this file.
+  #   config.example_status_persistence_file_path = "spec/examples.txt"
+  #
+  #   # Limits the available syntax to the non-monkey patched syntax that is
+  #   # recommended. For more details, see:
+  #   #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  #   config.disable_monkey_patching!
+  #
+  #   # This setting enables warnings. It's recommended, but in some cases may
+  #   # be too noisy due to issues in dependencies.
+  #   config.warnings = true
+  #
+  #   # Many RSpec users commonly either run the entire suite or an individual
+  #   # file, and it's useful to allow more verbose output when running an
+  #   # individual spec file.
+  #   if config.files_to_run.one?
+  #     # Use the documentation formatter for detailed output,
+  #     # unless a formatter has already been configured
+  #     # (e.g. via a command-line flag).
+  #     config.default_formatter = "doc"
+  #   end
+  #
+  #   # Print the 10 slowest examples and example groups at the
+  #   # end of the spec run, to help surface which specs are running
+  #   # particularly slow.
+  #   config.profile_examples = 10
+  #
+  #   # Run specs in random order to surface order dependencies. If you find an
+  #   # order dependency and want to debug it, you can fix the order by providing
+  #   # the seed, which is printed after each run.
+  #   #     --seed 1234
+  #   config.order = :random
+  #
+  #   # Seed global randomization in this process using the `--seed` CLI option.
+  #   # Setting this allows you to use `--seed` to deterministically reproduce
+  #   # test failures related to randomization by passing the same `--seed` value
+  #   # as the one that triggered the failure.
+  #   Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,174 @@
+--- !ruby/object:Gem::Specification
+name: ttt-cli
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+platform: ruby
+authors:
+- dionixs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.21.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.21.0
+- !ruby/object:Gem::Dependency
+  name: tty-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+description: 
+email:
+- dionixs@tutanota.com
+executables:
+- ttt-cli
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/console
+- bin/setup
+- bin/ttt-cli
+- lib/ttt-cli.rb
+- lib/ttt-cli/ai.rb
+- lib/ttt-cli/board.rb
+- lib/ttt-cli/display.rb
+- lib/ttt-cli/emoji.rb
+- lib/ttt-cli/engine.rb
+- lib/ttt-cli/game.rb
+- lib/ttt-cli/judge.rb
+- lib/ttt-cli/player.rb
+- lib/ttt-cli/players/computer.rb
+- lib/ttt-cli/players/human.rb
+- lib/ttt-cli/strategies/hard_ai.rb
+- lib/ttt-cli/strategies/medium_ai.rb
+- lib/ttt-cli/strategies/random_ai.rb
+- lib/ttt-cli/version.rb
+- spec/ai_spec.rb
+- spec/board_spec.rb
+- spec/game_spec.rb
+- spec/judge_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/dionixs/ttt-cli
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Консольная реализация игры "Крестики-нолики"
+test_files: []