rttt 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6b315e2219bf31c09ba048bb4146d5e94fa4ebe9
+  data.tar.gz: e37ab3d75a80f405f3b8cce6eb51dcb2b690861e
+SHA512:
+  metadata.gz: b332b109191dd60d1c4bf0f174784618a7566b69401bc000af3cca4275a35aacdf20a14564b5f48d8d16232f795abf291d7c13ac256131bfb4596c0a2f2ae069
+  data.tar.gz: c6401dc23e7a92d2e757bb1b22b76498bf868b4b37cc81af6152798a259f8a6ccf5f561ec9efd463b6a1cc5c0fdb4f2955f12aabdb4a11f22d4f3d3b328f711e

data/lib/ai.rb

@@ -0,0 +1,36 @@
+require 'player_manager'
+require 'state'
+
+class Ai
+  attr_reader :mark, :choice
+
+  def initialize(mark, manager)
+    @mark = mark
+    @state = State.new(manager)
+    @manager = manager
+  end
+  
+  def score(board, mark)
+    if @state.winner?(board, mark) || @state.winner?(board, @manager.other_mark(mark))
+      -10
+    else
+      0
+    end  
+  end
+  
+  def score_moves(board, mark, depth, scores)
+    return score(board, mark) if @state.terminal?(board) || (board.size == 16 && depth == 2)
+    @state.empty_indices(board).each do |move|
+      board[move] = mark
+      scores[move] = -1 * score_moves(board, @manager.other_mark(mark), depth + 1, Hash.new)
+      board[move] = "-"
+    end
+    best_score = scores.values.max
+    depth == 0 ? scores : best_score
+  end
+  
+  def smart_move(board)
+    @choice = score_moves(board, @mark, 0, Hash.new).max_by{ |k, v| v }[0]
+  end
+
+end

data/lib/board.rb

@@ -0,0 +1,21 @@
+class Board
+  attr_reader :board
+
+  def initialize(n)
+    @board = Array.new(n*n, "-")
+  end
+
+  def place(mark, loc)
+    @board[loc] = mark if valid?(loc)
+    @board
+  end
+
+  def valid?(loc)
+    @board[loc] == "-" && loc > -1 && loc < @board.length
+  end
+
+  def value_board
+    @board.clone
+  end
+
+end

data/lib/player_manager.rb

@@ -0,0 +1,36 @@
+require 'ai.rb'
+
+class Player_manager
+  attr_reader :first, :second
+
+  def initialize(first, ai_one, second, ai_two)
+    @first = first
+    @second = second
+
+    @players = {}
+    if ai_one == true
+      @players[@first] = Ai.new(@first, self)
+    else
+      @players[@first] = "human"
+    end
+
+    if ai_two == true
+      @players[@second] = Ai.new(@second, self)
+    else
+      @players[@second] = "human"
+    end
+  end
+  
+  def other_mark(mark)
+    if mark == @first
+      @second
+    else
+      @first
+    end
+  end
+
+  def get_player(mark)
+    @players[mark]
+  end
+
+end

data/lib/state.rb

@@ -0,0 +1,71 @@
+class State
+  def initialize(manager)
+    @manager = manager
+  end
+
+  def empty_indices(board)
+    indices = []
+    for i in 0..board.length - 1
+      indices.push(i) if board[i] == "-"
+    end
+    indices
+  end
+
+  def full?(board)
+    empty_indices(board) == []
+  end
+
+  def tie?(board)
+    full?(board) && !winner?(board, @manager.first) && !winner?(board, @manager.second) 
+  end
+
+  def horizontal?(board, mark)
+    count = 0
+    (0..board.size - 1).each do |pos|
+      count = 0 if pos % Math.sqrt(board.size) == 0
+      if board[pos] == mark
+        count += 1
+        return true if count == Math.sqrt(board.size)
+      end
+    end
+    return false
+  end
+
+  def vertical?(board, mark)
+    (0..Math.sqrt(board.size) - 1).each do |col|
+      count = 0
+      for row in 0..board.size - 1
+        count += 1 if (row % Math.sqrt(board.size)) == 0 && board[col+row] == mark
+      end
+      return true if count == Math.sqrt(board.size)  
+    end
+    return false
+  end
+
+  def diagonal_major?(board, mark)
+    count = 0
+    (0..board.size - 1).each do |pos|
+      count += 1 if (pos % (Math.sqrt(board.size) + 1)) == 0 && board[pos] == mark
+      return true if count == Math.sqrt(board.size)
+    end
+    return false
+  end
+
+  def diagonal_minor?(board, mark)
+    count = 0
+    (Integer(Math.sqrt(board.size) - 1)..board.size - (Math.sqrt(board.size))).each do |pos|
+      count += 1 if (pos % (Math.sqrt(board.size) - 1)) == 0 && board[pos] == mark
+      return true if count == Math.sqrt(board.size)
+    end
+    return false
+  end
+
+  def winner?(board, mark)
+    horizontal?(board, mark) || vertical?(board, mark) || diagonal_major?(board, mark) || diagonal_minor?(board, mark)
+  end
+
+  def terminal?(board)
+    winner?(board, @manager.first) || winner?(board, @manager.second) || tie?(board)
+  end
+
+end

data/spec/ai_spec.rb

@@ -0,0 +1,86 @@
+require 'state'
+require 'ai'
+require 'player_manager'
+
+describe Ai do
+  let(:m) {Player_manager.new("x", false, "o", true)}
+  let(:a) {Ai.new("o", m)}
+
+  it "scores all games -10" do
+    board = ["o", "o", "o","-","-","-","-","-","-"]
+    a.score(board, "o").should eq(-10)
+    
+    board = ["x", "x", "x","-","-","-","-","-","-"]
+    a.score(board, "o").should eq(-10)
+  end
+
+
+  it "doesn't score a draw a -10" do
+    board = ["x", "o", "x",
+             "o", "-", "-",
+             "x", "-", "o"]
+    a.score(board, "o").should eq(0)
+
+    board = ["x", "o", "x",
+             "o", "-", "-",
+             "x", "-", "o"]
+    a.score(board, "x").should eq(0)
+  end
+
+  it "scores a draw 0" do
+    board = ["x", "o", "x","x","o","o","o","x","x"]
+    a.score(board, "o").should eq(0)
+  end
+
+  it "if game is over, return the score for that branch" do
+    board = ["o", "o", "o","-","-","-","-","-","-"]
+    a.score(board, "o").should eq(-10)
+    board = ["x", "x", "x","-","-","-","-","-","-"]
+    a.score(board, "o").should eq(-10)
+    board = ["x", "o", "x","x","o","o","o","x","x"]
+    a.score(board, "o").should eq(0)
+  end
+
+  it "should take the correct move" do
+    board = ["x", "x", "-","-","o","-","-","-","-"]
+    a.smart_move(board)
+    a.choice.should eq(2)
+
+    board = ["o", "o", "x","-","-","-","x","-","-"]
+    a.smart_move(board)
+    a.choice.should eq(4)
+
+    board = ["-", "-", "o","-","o","x","x","-","x"]
+    a.smart_move(board)
+    a.choice.should eq(7)
+
+    board = ["x", "x", "o","-","o","-","x","-","-"]
+    a.smart_move(board)
+    a.choice.should eq(3)
+  end
+  
+  it "should block a fork" do
+    board = ["-", "-", "-",
+             "-", "x", "-",
+             "x", "-", "o"]
+    a.smart_move(board)
+    a.choice.should eq(2)
+  end
+
+  it "another fork" do
+    board = ["-", "-", "x",
+             "-", "x", "-",
+             "o", "-", "-"]
+    a.smart_move(board)
+    [0, 8].should include(a.choice)
+  end
+
+  it "another fork" do
+    board = ["x", "o", "x",
+             "-", "-", "-",
+             "-", "-", "-"]
+    a.smart_move(board)
+    [4, 6, 8].should include(a.choice)
+  end 
+
+end

data/spec/board_spec.rb

@@ -0,0 +1,46 @@
+require 'board'
+
+describe Board do
+  let(:b) {Board.new(3)}
+
+  it "initializes an empty board with blank (-) spaces" do
+    b.board.should eq(["-", "-","-","-","-","-","-","-","-"])
+  end
+
+  it "can take an piece" do
+    b.place("x", 0).should eq(["x", "-","-","-","-","-","-","-","-"])
+  end
+
+  it "index out of bounds (lower) aren't valid" do
+    b.valid?(-1).should eq(false)
+  end
+
+  it "index out of bounds (greater) aren't valid" do
+    b.valid?(9).should eq(false)
+  end
+
+  it "Taken positions are not valid" do
+    b.place("x", 0)
+    b.valid?(0).should eq(false)
+  end
+
+  it "won't place a piece in an invalid spot" do
+    b.place("x", -1).should eq(["-", "-","-","-","-","-","-","-","-"])
+  end
+
+  it "won't place a piece in an invalid spot" do
+    b.place("x", 11).should eq(["-", "-","-","-","-","-","-","-","-"])
+  end
+
+  it "won't place a piece in an taken position" do
+    b.place("x", 0)
+    b.place("o", 0).should eq(["x", "-","-","-","-","-","-","-","-"])
+  end
+
+  it "passed by values not by reference" do
+    board = b.value_board
+    board[8] = "x"
+    b.board.should eq(["-", "-","-","-","-","-","-","-","-"])
+  end
+
+end

data/spec/player_manager_spec.rb

@@ -0,0 +1,20 @@
+require 'player_manager'
+
+describe Player_manager do
+  let(:p) {Player_manager.new("x", false, "o", true)}
+  
+  it "reports opposing player" do
+    p.other_mark("x").should eq("o")
+  end
+
+  it "reports opposing player" do
+    p.other_mark("x").should eq("o")
+  end
+
+  it "knows if player is ai or not" do
+    p.get_player("x").should eq("human") 
+    player = p.get_player("o")
+    player.class.should eq(Ai)
+  end
+  
+end

data/spec/state_spec.rb

@@ -0,0 +1,152 @@
+require 'state'
+require 'board'
+require 'player_manager'
+
+describe State do
+  let(:b) {Board.new(3)}
+  let(:m) {Player_manager.new("x", false, "o", true)}
+  let(:s) {State.new(m)}
+
+  it "returns indices of empty positions on board" do
+    s.empty_indices(b.board).should eq([0, 1, 2, 3, 4, 5, 6, 7, 8])
+  end
+
+  it "won't return filled positions" do
+    s.empty_indices(b.place("x", 0)).should eq([1, 2, 3, 4, 5, 6, 7, 8])
+  end
+
+  it "reports if the board is full" do
+    board = ["x", "o","x","o","o","o","x","o","x"]
+    s.full?(board).should eq(true)
+  end
+
+  it "won't if it isn't" do
+    board = ["x", "o","x","o","x","o","-","-","-"]
+    s.full?(board).should eq(false)
+  end
+
+  it "reports status in horizontal row" do
+    board = ["x", "x", "x","-","-","-","-","-","-"]
+    s.horizontal?(board, "x").should eq(true)
+    board = ["-","-","-","-","-","-","x", "x", "x"]
+    s.horizontal?(board, "x").should eq(true)
+    board = ["-","-","-","-","-","-","o", "x", "x"]
+    s.horizontal?(board, "x").should eq(false)
+    board = ["-", "-", "-",
+             "o", "x", "x",
+             "-", "-", "-"]
+    s.horizontal?(board, "x").should eq(false)
+    board = ["o", "-", "o",
+             "-", "x", "-", 
+             "x", "-", "x"]
+    s.horizontal?(board, "x").should eq(false)
+  end
+
+  it "reports status in vertical row" do
+    board = ["x", "-", "-","x","-","-","x","-","-"]
+    s.vertical?(board, "x").should eq(true)
+    board = ["-", "-", "x","-","-","x","-","-","x"]
+    s.vertical?(board, "x").should eq(true)
+    board = ["x", "-", "-",
+             "-", "x", "-",
+             "x", "-", "-"]
+    s.vertical?(board, "x").should eq(false) 
+    board = ["o", "-", "o",
+             "x", "o", "-", 
+             "x", "-", "x"]
+    s.vertical?(board, "x").should eq(false)
+  end
+
+  it "reports status in major diagonal row" do
+    board = ["x", "-", "-",
+             "-","x","-",
+             "-","-","x"]
+    s.diagonal_major?(board, "x").should eq(true)
+    board = ["-", "-", "x",
+             "-", "-", "x",
+             "-" ,"-", "x"]
+    s.diagonal_major?(board, "x").should eq(false)
+    board = ["o", "-", "o",
+             "-", "x", "-", 
+             "x", "-", "x"]
+    s.diagonal_major?(board, "x").should eq(false)
+
+    board = ["x", "-", "-",
+             "-","x","-",
+             "-","-","-"]
+    s.diagonal_major?(board, "x").should eq(false)
+  end
+
+  it "reports status in minor diagonal row" do
+    board = ["-", "-", "x",
+             "-", "x", "-",
+             "x", "-", "-"]
+    s.diagonal_minor?(board, "x").should eq(true)
+    board = ["-", "-", "x",
+             "-", "-", "x", 
+             "-", "-", "x"]
+    s.diagonal_minor?(board, "x").should eq(false)
+    board = ["o", "-", "o",
+             "-", "x", "-", 
+             "x", "-", "x"]
+    s.diagonal_minor?(board, "x").should eq(false)
+    board = ["-", "-", "-",
+             "-", "x", "-", 
+             "x", "-", "o"]
+    s.diagonal_minor?(board, "x").should eq(false)
+  end
+
+  it "reports winner" do
+    board = ["x", "-", "-","-","x","-","-","-","x"]
+    s.winner?(board, "x").should eq(true)
+    board = ["x", "-", "-","x","-","-","x","-","-"]
+    s.winner?(board, "x").should eq(true)
+    board = ["x", "x", "x","-","-","-","-","-","-"]
+    s.winner?(board, "x").should eq(true)
+    board = ["o", "-", "o",
+             "-", "x", "-", 
+             "x", "-", "x"]
+    s.winner?(board, "x").should eq(false)
+  end
+
+  it "reports end of game (win or draw)" do
+    board = ["x", "-", "-","-","x","-","-","-","x"]
+    s.terminal?(board).should eq(true)
+    board = ["x", "o", "x","x","o","x","o","x","o"]
+    s.terminal?(board).should eq(true)
+  end
+
+  it "reports if the board is a tie game" do
+    board = ["x", "o","x","o","o","o","x","o","x"]
+    s.tie?(board).should eq(false)
+  end
+
+  it "hmmm?" do
+    board = ["x", "x", "o","x","o","o","x","-","-"]
+    s.winner?(board, "x").should eq(true)
+  end
+
+  it "work the same 4x4" do
+    board = ["x", "x", "x","x",
+             "-", "-", "-", "-",
+             "-", "-", "-", "-",
+             "-", "-", "-", "-"]
+    s.horizontal?(board, "x").should eq(true)
+    board = ["x", "-", "-","-",
+             "x", "-", "-", "-",
+             "x", "-", "-", "-",
+             "x", "-", "-", "-"]
+    s.vertical?(board, "x").should eq(true)
+    board = ["x", "-", "-","-",
+             "-", "x", "-", "-",
+             "-", "-", "x", "-",
+             "-", "-", "-", "x"]
+    s.diagonal_major?(board, "x").should eq(true)
+    board = ["-", "-", "-","x",
+             "-", "-", "x", "-",
+             "-", "x", "-", "-",
+             "x", "-", "-", "-"]
+    s.diagonal_minor?(board, "x").should eq(true)
+  end
+
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: rttt
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Andrew Spalding
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Unbeatable tic tac toe to be plugged into a user interface.
+email: aspalding@8thlight.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ai.rb
+- lib/state.rb
+- lib/board.rb
+- lib/player_manager.rb
+- spec/ai_spec.rb
+- spec/state_spec.rb
+- spec/board_spec.rb
+- spec/player_manager_spec.rb
+homepage: http://rubygems.org/gems/rttt
+licenses:
+- ''
+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.0.14
+signing_key: 
+specification_version: 4
+summary: Unbeatable tic tac toe.
+test_files:
+- spec/ai_spec.rb
+- spec/state_spec.rb
+- spec/board_spec.rb
+- spec/player_manager_spec.rb