tic_tac_toe_mchliakh 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f0630392041b9d59eb4b0774816016ea84e30272
+  data.tar.gz: b4b13cc7ee428545521ae95dff0e3388d39bd0db
+SHA512:
+  metadata.gz: 1e7b9a00a99008344992afb5fc554ba34dd90c15217997e9449602490484e723a428aa0f71e189927434353933547095b73c5585e37fc8f8fcb9cea3ae2694c0
+  data.tar.gz: 92c7ef80064c5d886d8580adbbe87fb064dc24caec63e666bf1cd9f68aa5c5e24370681339a58bfb7bd2ee8f03b55cc03173a804f60613e244438845e0561bd0

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tic_tac_toe_mchliakh.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Mikhail Chliakhovski
+
+MIT License
+
+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,41 @@
+# Tic-tac-toe
+
+A Tic-tac-toe game that never loses.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tic_tac_toe_mchliakh'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tic_tac_toe_mchliakh
+
+## Usage
+
+```ruby
+class MovesController < ActionController::Base
+  def make
+    game = if params[:game_id]
+      Game.new
+    else
+      Game.find(params[:game_id])
+    end
+
+    render json: TicTacToeMchliakh.move(params[:square], game.board)
+  end
+end
+```
+
+1. Fork it ( https://github.com/[my-github-username]/tic_tac_toe_mchliakh/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task default: :spec
+task test: :spec

data/lib/tic_tac_toe_mchliakh/board/board.rb

@@ -0,0 +1,77 @@
+module TicTacToeMchliakh
+  class Board
+    attr_reader :squares, :lines, :winner
+
+    def initialize(saved=nil)
+      setup do
+        if saved
+          saved.map.with_index do |s, n|
+            squares << Square.new(self, n + 1, s)
+          end
+        else
+          9.times {|n| squares << Square.new(self, n + 1) }
+        end
+      end
+    end
+
+    def square(number)
+      unless (1..9).include?(number)
+        raise RangeError, 'Choose a number between 1 and 9'
+      end
+
+      squares[number - 1]
+    end
+
+    def game_over?
+      !!@game_over
+    end
+
+    def square_taken
+      game_over if squares.all_taken?
+    end
+
+    def three_in_a_row(player)
+      @winner = player
+      game_over
+    end
+
+    def serialize
+      squares.map(&:serialize)
+    end
+
+    private
+
+    def setup
+      @squares = Squares.new
+      yield
+      build_lines
+    end
+
+    def build_lines
+      @lines = Lines.new
+
+      lines_of_three.each do |lot|
+        lines << Line.new(self,
+          Squares.new(lot.map {|s| squares[s] })
+        )
+      end
+    end
+
+    def lines_of_three
+      [
+        [0, 1, 2],
+        [2, 5, 8],
+        [6, 7, 8],
+        [0, 3, 6],
+        [1, 4, 7],
+        [3, 4, 5],
+        [0, 4, 8],
+        [2, 4, 6]
+      ]
+    end
+
+    def game_over
+      @game_over = true
+    end
+  end
+end

data/lib/tic_tac_toe_mchliakh/board/line.rb

@@ -0,0 +1,51 @@
+module TicTacToeMchliakh
+  class Line
+    attr_reader :squares
+
+    def initialize(board, squares)
+      @board = board
+      @squares = squares
+      listen
+    end
+
+    def &(other)
+      squares & other.squares
+    end
+
+    def can_win?(player)
+      squares.taken_by(player).count == 2 &&
+        squares.empty.one?
+    end
+
+    def can_lose?(player)
+      squares.taken_by_opponent(player).count == 2 &&
+        squares.empty.one?
+    end
+
+    def could_win?(player)
+      squares.taken_by(player).one? &&
+        squares.empty.count == 2
+    end
+
+    def could_lose?(player)
+      squares.taken_by_opponent(player).one? &&
+        squares.empty.count == 2
+    end
+
+    def square_taken
+      if three_in_a_row?
+        @board.three_in_a_row(squares.first.player)
+      end
+    end
+
+    private
+
+    def three_in_a_row?
+      squares.all_taken? && squares.all_equal?
+    end
+
+    def listen
+      squares.each {|s| s << self }
+    end
+  end
+end

data/lib/tic_tac_toe_mchliakh/board/lines.rb

@@ -0,0 +1,31 @@
+module TicTacToeMchliakh
+  class Lines < Array
+    def can_win(player)
+      select {|l| l.can_win?(player) }
+    end
+
+    def can_lose(player)
+      select {|l| l.can_lose?(player) }
+    end
+
+    def could_win(player)
+      select {|l| l.could_win?(player) }
+    end
+
+    def could_lose(player)
+      select {|l| l.could_lose?(player) }
+    end
+
+    def squares_that_can_fork(player)
+      Squares.new(could_win(player).combination(2).map do |ll|
+        (ll.first & ll.last).first
+      end.compact)
+    end
+
+    def squares_that_can_be_forked(player)
+      Squares.new(could_lose(player).combination(2).map do |ll|
+        (ll.first & ll.last).first
+      end.compact)
+    end
+  end
+end

data/lib/tic_tac_toe_mchliakh/board/square.rb

@@ -0,0 +1,55 @@
+module TicTacToeMchliakh
+  class IllegalMoveError < StandardError; end
+
+  class Square
+    attr_reader :player, :number
+
+    def initialize(board, number, saved=nil)
+      @board = board
+      @number = number
+      @player = saved
+      @lines = []
+    end
+
+    def ==(other)
+      other.player == player
+    end
+
+    def <<(line)
+      @lines << line
+    end
+
+    def line_count
+      @lines.size
+    end
+
+    def take(player)
+      raise IllegalMoveError, 'Square already taken' unless empty?
+
+      @player = player
+      notify
+    end
+
+    def empty?
+      player.nil?
+    end
+
+    def taken_by?(player)
+      self.player == player
+    end
+
+    def taken_by_opponent?(player)
+      !empty? && !taken_by?(player)
+    end
+
+    def serialize
+      player
+    end
+
+    private
+
+    def notify
+      ([@board] + @lines).map(&:square_taken)
+    end
+  end
+end

data/lib/tic_tac_toe_mchliakh/board/squares.rb

@@ -0,0 +1,23 @@
+module TicTacToeMchliakh
+  class Squares < Array
+    def empty
+      select(&:empty?)
+    end
+
+    def taken_by(player)
+      select {|s| s.taken_by?(player) }
+    end
+
+    def taken_by_opponent(player)
+      select {|s| s.taken_by_opponent?(player) }
+    end
+
+    def all_taken?
+      none?(&:empty?)
+    end
+
+    def all_equal?
+      all? {|s| s == first }
+    end
+  end
+end

data/lib/tic_tac_toe_mchliakh/players/computer.rb

@@ -0,0 +1,44 @@
+module TicTacToeMchliakh
+  class Computer < Player
+    def next_move
+      line = any_winning_line || any_losing_line
+
+      if line
+        line.squares.empty.sample
+      else
+        forks.sample || sticky_situation || @board.squares.empty.max_by(&:line_count)
+      end
+    end
+
+    private
+
+    def any_winning_line
+      @board.lines.can_win(@number).sample
+    end
+
+    def any_losing_line
+      @board.lines.can_lose(@number).sample
+    end
+
+    def forks
+      @board.lines.squares_that_can_fork(@number).empty
+    end
+
+    def opponent_forks
+      @board.lines.squares_that_can_be_forked(@number).empty
+    end
+
+    def sticky_situation
+      _opponent_forks = opponent_forks
+
+      if opponent_forks.size > 1
+        @board.lines.could_win(@number).each do |l|
+          non_fork = (l.squares.empty - (l.squares & _opponent_forks)).first
+          return (l.squares.empty - [non_fork]).first
+        end
+      else
+        opponent_forks.first
+      end
+    end
+  end
+end

data/lib/tic_tac_toe_mchliakh/players/player.rb

@@ -0,0 +1,11 @@
+module TicTacToeMchliakh
+  class Player
+    def initialize(board, number)
+      @board, @number = board, number
+    end
+
+    def next_move
+      raise NotImplementedError
+    end
+  end
+end

data/lib/tic_tac_toe_mchliakh/version.rb

@@ -0,0 +1,3 @@
+module TicTacToeMchliakh
+  VERSION = '0.1.0'
+end

data/lib/tic_tac_toe_mchliakh.rb

@@ -0,0 +1,29 @@
+require 'tic_tac_toe_mchliakh/board/square'
+require 'tic_tac_toe_mchliakh/board/squares'
+require 'tic_tac_toe_mchliakh/board/line'
+require 'tic_tac_toe_mchliakh/board/lines'
+require 'tic_tac_toe_mchliakh/board/board'
+require 'tic_tac_toe_mchliakh/players/player'
+require 'tic_tac_toe_mchliakh/players/computer'
+
+module TicTacToeMchliakh
+  def self.move(square, saved_board=nil)
+    board = Board.new(saved_board)
+    board.square(square).take(1)
+
+    if board.game_over?
+      return { board: board.serialize, winner: board.winner }
+    end
+
+    computer = Computer.new(board, 0)
+    computer.next_move.take(0)
+
+    if board.game_over?
+      { board: board.serialize, winner: board.winner }
+    else
+      { board: board.serialize }
+    end
+  rescue IllegalMoveError => e
+    { error: e.message }
+  end
+end

data/spec/board/board_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module TicTacToeMchliakh
+  describe Board do
+    before do
+      @board = Board.new
+    end
+
+    it 'gets a square' do
+      expect(@board.square(1).number).to eq(1)
+    end
+
+    it 'loads itself' do
+      saved = Board.new(Array.new(9, 123))
+      expect(saved.squares).to be_all_taken
+    end
+
+    it 'raises an error when square is not 1 to 9' do
+      expect {
+        @board.square(0).to raise_error(RangeError)
+      }
+      expect {
+        @board.square(10).to raise_error(RangeError)
+      }
+    end
+
+    it 'serializes itself' do
+      expect(@board.serialize).to eq(Array.new(9))
+    end
+  end
+end

data/spec/board/line_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module TicTacToeMchliakh
+  describe Line do
+    before do
+      @square = Square.new(nil, 0, 123)
+      @line = Line.new(nil, Squares.new([@square]))
+    end
+
+    it 'takes an intresection' do
+      other = Line.new(nil, Squares.new([@square]))
+      expect((@line & other).size).to be(1)
+    end
+
+    it 'knows when a player can win' do
+      winning_line = Line.new(
+        nil, Squares.new([@square, @square, Square.new(nil, 0)])
+      )
+      expect(winning_line.can_win?(123)).to be(true)
+    end
+
+    it 'knows when an player can lose' do
+      winning_line = Line.new(
+        nil, Squares.new([@square, @square, Square.new(nil, 0)])
+      )
+      expect(winning_line.can_lose?(321)).to be(true)
+    end
+
+    it 'knows when a player could win' do
+      empty_square = Square.new(nil, 0)
+      maybe_line = Line.new(
+        nil, Squares.new([@square, empty_square, empty_square])
+      )
+      expect(maybe_line.could_win?(123)).to be(true)
+    end
+
+    it 'knows when a player could lose' do
+      empty_square = Square.new(nil, 0)
+      maybe_line = Line.new(
+        nil, Squares.new([@square, empty_square, empty_square])
+      )
+      expect(maybe_line.could_lose?(321)).to be(true)
+    end
+
+    it 'notifies board when three in a row' do
+      board = double()
+      expect(board).to receive(:three_in_a_row).with(123)
+
+      three_in_a_row = Line.new(
+        board, Squares.new([@square, @square, @square])
+      )
+      three_in_a_row.square_taken
+    end
+  end
+end

data/spec/board/lines_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+module TicTacToeMchliakh
+  describe Lines do
+    before do
+      @board = Board.new([
+          0, nil,   0,
+        nil, nil, nil,
+        nil, nil, nil
+      ])
+    end
+
+    it 'finds winning lines' do
+      expect(@board.lines.can_win(0).count).to be(1)
+    end
+
+    it 'finds losing lines' do
+      expect(@board.lines.can_lose(1).count).to be(1)
+    end
+
+    it 'finds potentially winning lines' do
+      expect(@board.lines.could_win(0).count).to be(4)
+    end
+
+    it 'finds potentially losing lines' do
+      expect(@board.lines.could_lose(1).count).to be(4)
+    end
+
+    context 'opponent can fork' do
+      before do
+        @board = Board.new([
+            0, nil, nil,
+          nil,   1,   0,
+          nil, nil, nil
+        ])
+      end
+
+      it 'finds squares that can fork' do
+        squares_that_can_fork = @board.lines.squares_that_can_fork(0)
+        expect(squares_that_can_fork.empty.count).to be(1)
+      end
+
+      it 'finds squares that can be forked' do
+        squares_that_can_be_forked = @board.lines.squares_that_can_be_forked(1)
+        expect(squares_that_can_be_forked.empty.count).to be(1)
+      end
+    end
+  end
+end

data/spec/board/square_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+module TicTacToeMchliakh
+  describe Square do
+    before do
+      @board = double()
+      allow(@board).to receive(:square_taken)
+
+      @square = Square.new(@board, 0)
+    end
+
+    it 'is empty when initialized' do
+      expect(@square).to be_empty
+    end
+
+    it 'loads itself' do
+      saved = Square.new(@board, 0, 123)
+      expect(saved.player).to be(123)
+    end
+
+    it 'compares itself' do
+      other = Square.new(@board, 0)
+      expect(@square == other).to be(true)
+
+      @square.take(123)
+      expect(@square == other).to be(false)
+    end
+
+    it 'adds lines' do
+      expect(@square.line_count).to be(0)
+      @square << nil
+      expect(@square.line_count).to be(1)
+    end
+
+    it 'notifies board when taken' do
+      expect(@board).to receive(:square_taken)
+      @square.take(123)
+    end
+
+    it 'can only be taken once' do
+      @square.take(123)
+      expect {
+        @square.take(321)
+      }.to raise_error(IllegalMoveError)
+    end
+
+    it 'knows when taken by player' do
+      @square.take(123)
+      expect(@square.taken_by?(123)).to be(true)
+    end
+
+    it 'knows when taken by opponent' do
+      @square.take(321)
+      expect(@square.taken_by_opponent?(123)).to be(true)
+    end
+
+    it 'serializes itself' do
+      @square.take(123)
+      expect(@square.serialize).to be(123)
+    end
+  end
+end

data/spec/board/squares_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module TicTacToeMchliakh
+  describe Squares do
+    before do
+      @squares = Squares.new
+      [nil, 123, 321].each do |p|
+        @squares << Square.new(nil, 0, p)
+      end
+    end
+
+    it 'finds empty squares' do
+      expect(@squares.empty.count).to be(1)
+    end
+
+    it 'finds squares taken by player' do
+      expect(@squares.taken_by(123).count).to be(1)
+    end
+
+    it 'finds squares taken by opponent' do
+      expect(@squares.taken_by_opponent(123).count).to be(1)
+    end
+
+    it 'knows when all squares are taken' do
+      @squares[0] = Square.new(nil, 0, 123)
+      expect(@squares).to be_all_taken
+    end
+
+    it 'knows when all squares are equal' do
+      @squares[0] = @squares[2] = Square.new(nil, 0, 123)
+      expect(@squares).to be_all_equal
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'tic_tac_toe_mchliakh'

data/spec/tic_tac_toe_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module TicTacToeMchliakh
+  describe TicTacToeMchliakh do
+    it 'makes a move' do
+      expect(TicTacToeMchliakh.move(1)[:board].compact.sort)
+        .to eq([0, 1])
+    end
+
+    it 'returns an error when desired square is taken' do
+      expect(TicTacToeMchliakh.move(1, Array.new(9, 0)))
+        .to have_key(:error)
+    end
+  end
+end

data/tic_tac_toe_mchliakh.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tic_tac_toe_mchliakh/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'tic_tac_toe_mchliakh'
+  s.version       = TicTacToeMchliakh::VERSION
+  s.authors       = ['Mikhail Chliakhovski']
+  s.email         = ['mchliakh.dev@gmail.com']
+  s.summary       = 'Tic-tac-toe'
+  s.description   = 'A Tic-tac-toe game that never loses'
+  s.homepage      = 'http://github.com/mchliakh/tic_tac_toe'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files -z`.split("\x0")
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ['lib']
+
+  s.add_development_dependency 'bundler', '~> 1.7'
+  s.add_development_dependency 'rake', '~> 10.0'
+  s.add_development_dependency 'rspec', '~> 3.0'
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: tic_tac_toe_mchliakh
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mikhail Chliakhovski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A Tic-tac-toe game that never loses
+email:
+- mchliakh.dev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/tic_tac_toe_mchliakh.rb
+- lib/tic_tac_toe_mchliakh/board/board.rb
+- lib/tic_tac_toe_mchliakh/board/line.rb
+- lib/tic_tac_toe_mchliakh/board/lines.rb
+- lib/tic_tac_toe_mchliakh/board/square.rb
+- lib/tic_tac_toe_mchliakh/board/squares.rb
+- lib/tic_tac_toe_mchliakh/players/computer.rb
+- lib/tic_tac_toe_mchliakh/players/player.rb
+- lib/tic_tac_toe_mchliakh/version.rb
+- spec/board/board_spec.rb
+- spec/board/line_spec.rb
+- spec/board/lines_spec.rb
+- spec/board/square_spec.rb
+- spec/board/squares_spec.rb
+- spec/spec_helper.rb
+- spec/tic_tac_toe_spec.rb
+- tic_tac_toe_mchliakh.gemspec
+homepage: http://github.com/mchliakh/tic_tac_toe
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Tic-tac-toe
+test_files:
+- spec/board/board_spec.rb
+- spec/board/line_spec.rb
+- spec/board/lines_spec.rb
+- spec/board/square_spec.rb
+- spec/board/squares_spec.rb
+- spec/spec_helper.rb
+- spec/tic_tac_toe_spec.rb