x_and_os 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0d992babe9dd2b0f2ccde30604920cf3e8cc0f72
+  data.tar.gz: fbe6d30630b944476bc9a32e309970ec0745958f
+SHA512:
+  metadata.gz: 8ad4a9fb34a1f47d4b610b2a7fee71524cea7c6cad5028c94f713b5151d59f0ae441212c1047f1306101c3ad0c8ae9e436069e9991f9fa00f63d1b406424468f
+  data.tar.gz: 2594b09d691adcb49bd15830ef2309441f63aa1e361e60315e4f448ac86fe2080dc1df6912a612af04c6634841595253e4644be1dec79129d33bc82d0bf01945

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.1

data/Gemfile

@@ -0,0 +1,10 @@
+source 'http://rubygems.org'
+ruby '2.2.1'
+
+gemspec
+
+gem 'rspec', group: :test
+gem 'rake', group: :test
+gem 'pry', group: :test
+
+

data/README.md

@@ -0,0 +1,47 @@
+# XAndOs
+
+XAndOs provides the basic structure and game logic to easily create the game Tic Tac Toe.
+It also comes with a mini CLA to play Tic Tac Toe in the command line. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'x_and_os'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install x_and_os
+
+## Usage
+
+### Game
+  TODO
+### Board
+  TODO
+### Game Mastery
+  TODO
+
+### Command Line App
+You can use XAndOs to play Tic Tac Toe in the command line
+`x_and_os`
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/x_and_os/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 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "x_and_os"
+
+# 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

data/bin/setup

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

data/bin/x_and_os

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative '../cla/tic_tac_toe'
+
+TicTacToe::Application.new(ARGV)

data/cla/tic_tac_toe/application.rb

@@ -0,0 +1,88 @@
+require_relative './game_manager'
+require_relative './ui'
+
+module TicTacToe
+  class Application    
+    def initialize(argv)
+      start_app
+    end
+
+    def start_app
+      UI.output
+      UI.output 'Welcome to TicTacToe'
+      UI.output 'Quick Game?'
+      settings unless UI.receive =~ /^y/i
+      loop do 
+        play 
+        UI.output
+        UI.output 'Play again?'
+        break unless UI.receive =~ /^y/i
+        UI.output
+        UI.output 'Change settings?'
+        settings if UI.receive =~ /^y/i
+      end
+
+      UI.output
+      UI.output 'Thank you for playing.'
+    end
+
+    private
+
+    def settings
+      choose_player
+      choose_board_size
+    end
+
+    def choose_player
+      UI.output
+      UI.output 'Choose Player : '
+      UI.output '    p:     player'
+      UI.output '    c:     computer'
+      UI.output
+      UI.output 'Player 1'
+      @player_one = player_type(UI.receive)
+      UI.output
+      UI.output 'Player 2'
+      @player_two = player_type(UI.receive)
+      UI.output
+    end
+
+    def choose_board_size
+      UI.output
+      UI.output 'Enter Board Size :'
+      UI.output '  3: 3x3'
+      UI.output '  4: 4x4'
+      UI.output '  N: NxN'
+      UI.output
+      size = UI.receive
+      @board_size = (size.to_i >= 1) ? size : 3
+      UI.output
+    end
+
+    def play
+      GameManager.new(player_one, player_two, board_size).play
+    end
+
+    def player_one
+      @player_one ||= HumanPlayer
+    end
+
+    def player_two
+      @player_two ||= ComputerPlayer
+    end
+
+    def board_size
+      @board_size ||= 3
+    end
+
+
+    def player_type(player)
+      if player =~ /^p/i
+        HumanPlayer
+      elsif player =~ /^c/i
+        ComputerPlayer
+      end
+    end
+
+  end
+end

data/cla/tic_tac_toe/computer_player.rb

@@ -0,0 +1,21 @@
+require 'x_and_os'
+require_relative './nameable'
+
+module TicTacToe
+  class ComputerPlayer
+    include Nameable
+
+    attr_reader :board, :marker
+
+    def initialize(args)
+      @board  = args[:board]
+      @marker = args[:marker]
+      @game_master = XAndOs::GameMaster.new(board: board, marker: marker)
+    end
+    
+    def move
+      @game_master.best_move 
+    end
+  end
+end
+

data/cla/tic_tac_toe/display.rb

@@ -0,0 +1,56 @@
+require_relative './ui'
+
+module TicTacToe
+  module Display
+
+    def self.game_board(board)
+      height    = board.length
+      width     = board.first.length
+      padding   = (width * height).to_s.length
+      
+      UI.output
+      board.each_with_index do |row, row_index|
+        row_with_move_numbers = blank_cells_to_numbers(row, row_index)
+        
+        padded_row = add_padding_to_row(row_with_move_numbers, padding)
+
+        UI.output "\t " + padded_row.join(' | ')
+        UI.output  divider(width, padding) unless row_index + 1 >= height
+      end
+
+      UI.output
+    end
+
+    private
+
+    def self.divider(width, padding)
+      dividers = []
+      width.times do
+        dividers << ('-' * padding)
+      end
+
+      "\t #{dividers.join('-+-')}"
+    end
+
+    def self.add_padding_to_row(row, padding)
+      row.map do |cell|
+        format_string = "%-#{padding}s"
+        format_string % cell.to_s
+      end
+    end
+
+    def self.blank_cells_to_numbers(row, row_index)
+      previous_cells_count = row.length * row_index
+
+      row.map.with_index do |cell, column_index|
+        column_number = column_index + 1
+        not_blank(cell) ? cell : previous_cells_count + column_number
+      end
+    end
+
+    def self.not_blank(str)
+      /\S+/ =~ str.to_s
+    end
+
+  end
+end

data/cla/tic_tac_toe/game_manager.rb

@@ -0,0 +1,72 @@
+require 'x_and_os'
+require_relative './human_player'
+require_relative './computer_player'
+require_relative './display'
+require_relative './ui'
+
+module TicTacToe
+  class GameManager
+    include Display
+
+    attr_reader :player1, :player2, :turns
+
+    def initialize(player_1_class = HumanPlayer, player_2_class = ComputerPlayer, board_size = 3)
+      @game = XAndOs::Game.new(rows: board_size, columns: board_size)
+      @player1  = player_1_class.new(marker: 'x', board: board)
+      @player2  = player_2_class.new(marker: 'o', board: board)
+      @turns    = 0
+    end
+
+    def current_player
+      turns.even? ? player1 : player2
+    end
+
+    def last_player
+      turns.odd? ? player1 : player2
+    end
+
+    def board
+      @game.board
+    end
+
+    def play
+      print_intructions
+      loop do
+        if @game.winner?
+          Display.game_board(board.grid)
+          UI.output "#{last_player.name} wins!!"
+          break
+        elsif @game.draw?
+          Display.game_board(board.grid)
+          UI.output "It's a draw!!"
+          break
+        else
+          move
+        end
+      end
+    end
+
+    def move
+      player = current_player
+
+      Display.game_board(board.grid)
+      UI.output "#{player.name}'s turn."
+
+      cell = player.move
+
+      until @game.add_move(cell, player.marker)
+        UI.output "\nSorry, invalid entry. Please try again\n\n"
+        cell = player.move
+      end
+
+      @turns += 1
+    end
+
+    def print_intructions
+      UI.output 'Choose a number between 1 and 9 to mark space in the grid'
+      UI.output 'Place 3 marks in a horizontal, vertical, or diagonal row to win.'
+      UI.output
+    end
+
+  end
+end

data/cla/tic_tac_toe/human_player.rb

@@ -0,0 +1,18 @@
+require_relative './nameable'
+require_relative './ui'
+
+module TicTacToe
+  class HumanPlayer
+    include Nameable
+    
+    attr_reader :board, :marker
+
+    def initialize(args = {})
+      @marker = args[:marker]
+    end
+
+    def move
+      move = UI.receive
+    end
+  end
+end

data/cla/tic_tac_toe/nameable.rb

@@ -0,0 +1,16 @@
+module TicTacToe
+  module Nameable
+    attr_writer :name
+
+    def name
+      @name ||= name_creator
+    end
+
+    private
+
+    def name_creator
+      name = self.class.to_s.sub('TicTacToe::', '')
+      name += " #{marker}" if marker
+    end
+  end
+end

data/cla/tic_tac_toe/ui.rb

@@ -0,0 +1,13 @@
+module TicTacToe
+  module UI
+    def self.output(output_msg=nil, stdout= $stdout )
+      stdout.puts output_msg
+      # raise 'output called'
+    end
+
+    def self.receive(stdin= $stdin )
+      stdin.gets.chomp
+      # raise 'input called'
+    end
+  end
+end

data/cla/tic_tac_toe.rb

@@ -0,0 +1 @@
+require_relative './tic_tac_toe/application'

data/lib/x_and_os/board.rb

@@ -0,0 +1,103 @@
+class XAndOs::Board
+  attr_reader :grid, :default_value, :rows, :columns
+
+  def initialize(rows = 3, columns = 3, default_value = ' ')
+    @default_value = default_value
+    @rows          = rows.to_i
+    @columns       = columns.to_i
+    @grid          = new_grid
+  end
+
+  def set_cell(cell_num, value)
+    row, column = human_to_grid(cell_num)
+    if grid[row][column] == default_value
+      grid[row][column] = value
+    else
+      false
+    end
+  end
+
+  def get_cell(cell_num)
+    row, column = human_to_grid(cell_num)
+    grid[row][column]
+  end
+
+  def diagonal_rows
+    left_to_right = (0...rows).map { |i| grid[i][i] }
+    right_to_left = (0...rows).map { |i| grid[i][columns - (i + 1)] }
+    [left_to_right, right_to_left]
+  end
+
+  def vertical_rows
+    grid.transpose
+  end
+
+  def horizontal_rows
+    grid
+  end
+
+  def all_rows
+    diagonal_rows + vertical_rows + horizontal_rows
+  end
+
+  def complete_rows
+    all_rows.reject do |row|
+      uniq_values = row.uniq
+      uniq_values.include?(default_value) || uniq_values.count > 1
+    end
+  end
+
+  def all_lines
+    temp_board    = self.class.new(rows, columns)
+    num_of_cells  = rows * columns
+
+    (1..num_of_cells).each do |i|
+      temp_board.set_cell(i,i)
+    end
+
+    temp_board.all_rows
+  end
+
+  def count_cells
+    @total_cells ||= rows * columns
+  end
+
+  def find_cells value
+    grid.flatten.map.with_index { |val, i| i + 1 if val == value }.compact
+  end
+
+  def free_cells
+    find_cells default_value
+  end
+
+  def cell_locations
+    store = Hash.new {|h,k| h[k] = [] }
+    
+    grid.flatten.map.with_index.inject(store) do |store, (cell, index)|
+      if cell != default_value
+        store[cell].push(index + 1)
+      end
+      store
+    end
+  end
+
+  private
+
+  def human_to_grid(cell_num)
+    cell_num = cell_num.to_i - 1
+    [row_number(cell_num), column_number(cell_num)]
+  end
+
+  def row_number(cell_num)
+    cell_num / columns
+  end
+
+  def column_number(cell_num)
+    cell_num - (row_number(cell_num) * columns)
+  end
+
+  def new_grid
+    Array.new(rows) { Array.new(columns, default_value) }
+  end
+end
+

data/lib/x_and_os/game.rb

@@ -0,0 +1,28 @@
+class XAndOs::Game
+
+  attr_reader :board
+
+  def initialize(args = {})
+    rows = args[:rows] || 3
+    columns = args[:columns] || 3
+    @board = args[:board] || XAndOs::Board.new(rows,columns)
+  end
+
+  def add_move(cell, marker = get_marker)
+    self if board.set_cell(cell, marker)
+  end
+
+  def get_marker
+    (board.count_cells - board.free_cells.size).even? ? 'X' : 'O'
+  end
+
+  def winner?
+    board.complete_rows.count >= 1
+  end
+
+  def draw?
+    board.free_cells.size <= 0
+  end
+
+end
+

data/lib/x_and_os/game_master.rb

@@ -0,0 +1,139 @@
+module XAndOs
+  class GameMaster
+    attr_reader :board, :marker
+    def initialize(args = {})
+      @board      = args[:board]
+      @marker     = args[:marker]
+      @move_args  = {}
+    end
+
+    def best_move(args={})
+      @move_args = args
+      move = win || block || fork_move || force_block || block_fork
+      return move if move
+
+      if first_move
+        1
+      else
+        center || corner || available_moves.sample
+      end
+    end
+
+    def winning_lines
+      @winning_lines ||= build_winning_lines
+    end
+    
+    private
+
+    def mastery_board
+      @mastery_board  = @move_args[:board]  || board
+    end
+
+    def current_marker
+      @current_marker = @move_args[:marker] || marker
+    end
+
+    def build_winning_lines
+      mastery_board.all_lines
+    end
+
+    def total_cells
+      mastery_board.count_cells
+    end
+
+    def available_moves
+      mastery_board.free_cells
+    end
+
+    def moves_made
+      mastery_board.find_cells(current_marker)
+    end
+
+    def opponent_moves
+      (1..9).to_a - (moves_made + available_moves)
+    end
+
+    def first_move
+      available_moves.size == total_cells
+    end
+
+    def win
+      wining_moves(moves_made).sample
+    end
+
+    def block
+      wining_moves(opponent_moves).sample
+    end
+
+    def fork_move
+      fork_moves(moves_made).sample
+    end
+
+    def force_block
+      force_block_moves.sample
+    end
+
+    def block_fork
+      fork_moves(opponent_moves).sample
+    end
+
+    def center
+      # no center move for even numbered total cells
+      if mastery_board.count_cells.odd?
+        center_cell = (mastery_board.count_cells + 1) / 2
+        center_cell if available_moves.include?(center_cell)
+      end
+    end
+
+    def corner
+      available_moves.select do |move|
+        corner_moves.include?(move)
+      end.sample
+    end
+
+    def wining_moves(moves_made)
+      winning_lines.map do |line|
+        arr = line - moves_made
+
+        next unless arr.size == 1
+
+        available_moves.include?(arr.first) ? arr.first : nil
+      end.compact
+    end
+
+    def fork_moves(moves_made, moves_left = available_moves)
+      moves_left.map do |move|
+        future_moves = moves_made.dup << move
+
+        (wining_moves future_moves).size > 1 ? move : nil
+      end.compact
+    end
+
+    def force_block_moves
+      winning_lines.map do |line|
+        next unless (line & opponent_moves).empty? && (line & moves_made).any?
+
+        moves = line - moves_made
+
+        safe_moves(moves, line)
+      end.flatten.compact
+    end
+
+    def safe_moves(moves, line)
+      moves.map do |move|
+        forced_move = (line - (moves_made << move)).first
+
+        opponent_future_moves = opponent_moves << forced_move
+
+        wining_moves(opponent_future_moves).size < 2 ? move : nil
+      end
+    end
+
+    def corner_moves
+      # To be improved to dynamically work out corners
+      # and move logic to board
+      [1,3,7,9]
+    end
+    
+  end
+end

data/lib/x_and_os/version.rb

@@ -0,0 +1,3 @@
+module XAndOs
+  VERSION = "0.0.1"
+end

data/lib/x_and_os.rb

@@ -0,0 +1,6 @@
+require 'x_and_os/version'
+require 'x_and_os/game'
+require 'x_and_os/board'
+require 'x_and_os/game_master'
+
+

data/x_and_os.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'x_and_os/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "x_and_os"
+  spec.version       = XAndOs::VERSION
+  spec.authors       = ["Jonny"]
+  spec.email         = ["jonny.adshead@gmail.com"]
+
+  spec.summary       = %q{Tic tac toe command line game}
+  spec.description   = %q{Basic modules that allow you to build a tic tac toe game and a small cla to play Tic Tac Toe in the command line}
+  spec.homepage      = "http://github.com/JAdshead/xandos"
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = ["x_and_os"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: x_and_os
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jonny
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !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'
+description: Basic modules that allow you to build a tic tac toe game and a small
+  cla to play Tic Tac Toe in the command line
+email:
+- jonny.adshead@gmail.com
+executables:
+- x_and_os
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- bin/x_and_os
+- cla/tic_tac_toe.rb
+- cla/tic_tac_toe/application.rb
+- cla/tic_tac_toe/computer_player.rb
+- cla/tic_tac_toe/display.rb
+- cla/tic_tac_toe/game_manager.rb
+- cla/tic_tac_toe/human_player.rb
+- cla/tic_tac_toe/nameable.rb
+- cla/tic_tac_toe/ui.rb
+- lib/x_and_os.rb
+- lib/x_and_os/board.rb
+- lib/x_and_os/game.rb
+- lib/x_and_os/game_master.rb
+- lib/x_and_os/version.rb
+- x_and_os.gemspec
+homepage: http://github.com/JAdshead/xandos
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Tic tac toe command line game
+test_files: []