sams_tic_tac_toe 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 69fa18fbe3db990208b96d2c4548172003183e22fb33ee68f7e62c876673c39d
+  data.tar.gz: ae92cce1b2ba79b792b193adcc0cc0a48100e7430ceb4cdeca94501d3ded2aa3
+SHA512:
+  metadata.gz: 48a41718853b5ccaa35803208f9b09d17c2cb52d7f9c5efaf6a2a1aa0adafd21c1d2f0281cf5fc71636aebaa34b8e64f0d8fd7d1013bf0712f998e2a9ac3df40
+  data.tar.gz: 53bc39b7b03115dddb57650bb76a4df0274ead5b699004b2bc8d29a9fdead4cd1ea9282ffb2a1f761c8cc70e97475aab0a99eab2e8f894558f6d009a36820afe

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.DS_Store
+# rspec failure tracking
+.rspec_status

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,18 @@
+Layout/LineLength:
+  Max: 120
+
+Style/Documentation:
+  Enabled: false
+
+Naming/AccessorMethodName:
+    Enabled: false
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/MethodLength:
+  Max: 20
+
+Style/FrozenStringLiteralComment:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.14.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at eckmeier41@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Sam Eckmeier
+
+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,13 @@
+# TicTacToe
+
+## Description
+Welcome to a game of command-line, tic-tac-toe! It's important to note that the computer is extremely
+difficult to beat. If you do, then you might be a computer. Have fun!
+
+## Installation
+There are two ways to play this game:
+- Download this code here, through github, execute `bundle install` from the root dir, and finally run `bin/play_tic_tac_toe`
+- Run `gem install sams_tic_tac_toe` and execute `play_tic_tac_toe`
+
+If you decide to download this as a gem, make sure that you have RubyGems installed by running `gem --version` in your terminal.
+If it isn't installed, refer to https://github.com/rubygems/rubygems.

data/Rakefile

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

data/bin/play_tic_tac_toe

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'irb'
+require File.expand_path("#{File.dirname(__FILE__)}/../lib/tic_tac_toe.rb")
+
+begin
+  board_setup = Model::BoardSetup.new(
+    dimensions: 3,
+    board_klass: Model::Board,
+    tile_collection_klass: Model::TileCollection,
+    team_collection_klass: Model::TeamCollection,
+    game_state: Model::GameState,
+    tile_klass: Model::Tile
+  )
+  teams_setup = Model::TeamsSetup.new(
+    team_klass: Model::Team,
+    piece_klass: Model::Piece,
+    move_klass: Model::Move,
+    move_strategy_klass: Model::MoveStrategy
+  )
+  select_team_presenter = Presenter::SelectTeam.new(board_setup, teams_setup)
+  select_team_view = View::SelectTeam.new(select_team_presenter, Utils::Terminal)
+
+  begin
+    select_team_view.render
+  rescue InvalidSelection => e
+    puts e.message
+    puts 'Please Try Again :)'
+    retry
+  end
+
+  board = board_setup.create_board
+  board_presenter = Presenter::Board.new(board, Model::GameTree)
+  board_view = View::Board.new(board_presenter, Terminal::Table)
+  game_result_view = View::GameResult.new(board_presenter)
+  select_move_view = View::SelectMove.new(board_presenter, Utils::Terminal)
+
+  while board_presenter.continue?
+    Utils::Terminal.clear_screen
+
+    board_view.render
+
+    begin
+      select_move_view.render
+    rescue InvalidSelection => e
+      puts e.message
+      puts 'Please Try Again :)'
+      retry
+    end
+  end
+
+  Utils::Terminal.clear_screen
+
+  board_view.render
+
+  game_result_view.render
+rescue StandardError
+  puts 'Seems that something went wrong :( Sorry about that'
+end

data/lib/tic_tac_toe/errors/invalid_selection.rb

@@ -0,0 +1,5 @@
+class InvalidSelection < StandardError
+  def initialize(msg)
+    super(msg)
+  end
+end

data/lib/tic_tac_toe/model/board.rb

@@ -0,0 +1,71 @@
+module Model
+  class Board
+    attr_reader :tile_collection
+
+    def initialize(args)
+      @tile_collection = args[:tile_collection]
+      @team_collection = args[:team_collection]
+      @game_state = args[:game_state]
+    end
+
+    def dimensions
+      @tile_collection.dimensions
+    end
+
+    def set_piece(row, col, piece)
+      tile = @tile_collection.find_tile(row, col)
+
+      tile.piece = piece
+
+      tile
+    end
+
+    def tile_available?(row, col)
+      tile = @tile_collection.find_tile(row, col)
+
+      tile.piece.nil?
+    end
+
+    def available_moves
+      current_team.available_moves(self)
+    end
+
+    def available_tiles
+      @tile_collection.available_tiles
+    end
+
+    def complete?
+      available_tiles.count.zero? || !winner.nil?
+    end
+
+    def current_team
+      @team_collection.current
+    end
+
+    def cycle_teams
+      @team_collection.next
+    end
+
+    def winner
+      @game_state.winner(self)
+    end
+
+    def rating(team)
+      rating = @game_state.rating(self, team)
+
+      if rating.negative?
+        rating -= available_tiles.count
+      elsif rating.positive?
+        rating += available_tiles.count
+      end
+
+      rating
+    end
+
+    def clone
+      self.class.new(tile_collection: @tile_collection.clone,
+                     team_collection: @team_collection.clone,
+                     game_state: @game_state.clone)
+    end
+  end
+end

data/lib/tic_tac_toe/model/board_setup.rb

@@ -0,0 +1,30 @@
+module Model
+  class BoardSetup
+    attr_accessor :teams
+
+    def initialize(args)
+      @board_klass = args[:board_klass]
+      @tile_collection_klass = args[:tile_collection_klass]
+      @team_collection_klass = args[:team_collection_klass]
+      @game_state = args[:game_state]
+      @tile_klass = args[:tile_klass]
+      @dimensions = args[:dimensions]
+      @teams = []
+    end
+
+    def create_board
+      tiles = create_tiles
+
+      @board_klass.new(tile_collection: @tile_collection_klass.new(tiles, @dimensions),
+                       team_collection: @team_collection_klass.new(@teams),
+                       game_state: @game_state.new)
+    end
+
+    private
+
+    def create_tiles
+      cnt = @dimensions**2
+      (1..cnt).map { |_i| @tile_klass.new }
+    end
+  end
+end

data/lib/tic_tac_toe/model/game_state.rb

@@ -0,0 +1,114 @@
+module Model
+  class GameState
+    def winner(board)
+      tile_collection = board.tile_collection
+
+      rows(tile_collection) || cols(tile_collection) || diags(tile_collection)
+    end
+
+    def rating(board, team)
+      winner = winner(board)
+
+      return 0 unless winner
+
+      winner.name == team.name ? 1 : -1
+    end
+
+    private
+
+    def current_team?(current_team, team)
+      (team && current_team) && team.name == current_team.name
+    end
+
+    def team(row_i, col_i, tile_collection)
+      tile = tile_collection.find_tile(row_i, col_i)
+
+      tile.team
+    end
+
+    def rows(tile_collection)
+      dims = tile_collection.dimensions
+
+      (1..dims).each do |row_i|
+        current_team = team(row_i, 1, tile_collection)
+
+        (2..dims).each do |col_i|
+          team = team(row_i, col_i, tile_collection)
+
+          unless current_team?(current_team, team)
+            current_team = nil
+            break
+          end
+        end
+
+        return current_team if current_team
+      end
+
+      nil
+    end
+
+    def cols(tile_collection)
+      dims = tile_collection.dimensions
+
+      (1..dims).each do |col_i|
+        current_team = team(1, col_i, tile_collection)
+
+        (2..dims).each do |row_i|
+          team = team(row_i, col_i, tile_collection)
+
+          unless current_team?(current_team, team)
+            current_team = nil
+            break
+          end
+        end
+
+        return current_team if current_team
+      end
+
+      nil
+    end
+
+    def left_diag(tile_collection)
+      current_team = team(1, 1, tile_collection)
+      dims = tile_collection.dimensions
+
+      (2..dims).each do |i|
+        team = team(i, i, tile_collection)
+
+        unless current_team?(current_team, team)
+          current_team = nil
+          break
+        end
+      end
+
+      current_team
+    end
+
+    def right_diag(tile_collection)
+      dims = tile_collection.dimensions
+      col_i = dims
+      current_team = team(1, col_i, tile_collection)
+
+      (2..dims).each do |row_i|
+        col_i -= 1
+
+        team = team(row_i, col_i, tile_collection)
+
+        unless current_team?(current_team, team)
+          current_team = nil
+          break
+        end
+      end
+
+      current_team
+    end
+
+    def diags(tile_collection)
+      team = left_diag(tile_collection)
+
+      return team if team
+
+      right_diag(tile_collection)
+    end
+  end
+end

data/lib/tic_tac_toe/model/game_tree.rb

@@ -0,0 +1,72 @@
+# GameTree is an n-ary tree and produces its children dynamically.
+
+module Model
+  class GameTree
+    attr_reader :previous_move, :board
+
+    def initialize(board, previous_move = nil)
+      @board = board
+      @previous_move = previous_move
+      @equivalent = {}
+    end
+
+    class << self
+      def generate_game_tree(board, previous_move = nil)
+        new(board, previous_move)
+      end
+    end
+
+    def current_team
+      @board.current_team
+    end
+
+    def complete?
+      @board.complete? || next_game_trees.count.zero?
+    end
+
+    def rating(team)
+      @board.rating(team)
+    end
+
+    # Produces children based on the number of unique tile collection orientations.
+    # For more info, check out Model::TileCollection.
+    def next_game_trees
+      return @next_game_trees unless @next_game_trees.nil?
+
+      moves = @board.available_moves
+
+      @next_game_trees = moves.each_with_object([]) { |move, game_trees| add_game_trees(game_trees, move) }
+
+      @next_game_trees
+    end
+
+    private
+
+    def add_game_trees(game_trees, move)
+      tile = move.tile
+      board = @board.clone
+
+      board.set_piece(tile.row, tile.col, move.piece)
+
+      tile_collection = board.tile_collection
+
+      unless equivalent?(tile_collection.id)
+        add_equivalents(tile_collection)
+
+        board.cycle_teams
+
+        game_trees << self.class.generate_game_tree(board, move)
+      end
+
+      game_trees
+    end
+
+    def equivalent?(tile_collection_id)
+      @equivalent[tile_collection_id]
+    end
+
+    def add_equivalents(tile_collection)
+      tile_collection.equivalents.each { |tc| @equivalent[tc.id] = true }
+    end
+  end
+end

data/lib/tic_tac_toe/model/move.rb

@@ -0,0 +1,20 @@
+module Model
+  class Move
+    attr_reader :tile, :piece
+
+    def initialize(tile, piece)
+      @tile = tile
+      @piece = piece
+    end
+
+    class << self
+      def generate_moves(piece, board)
+        board.available_tiles.map { |tile| generate_move(tile, piece) }
+      end
+
+      def generate_move(tile, piece)
+        new(tile, piece)
+      end
+    end
+  end
+end

data/lib/tic_tac_toe/model/move_strategy.rb

@@ -0,0 +1,86 @@
+# This class uses the MinMax algorithm with alpha/beta pruning
+# This algorithim reflects the process of a player selecting moves
+# That maximize their chances of winning, while another player
+# Selects moves to minimize the other player's chances of winning.
+# MinMax traverses a GameTree in a DFS manner and at each level promotes
+# The highest or lowest GameTree leaf rating, relative to adjacent GameTrees,
+# Depending on whether MinMax is executing in a maximizing or minimizing context.
+# Alpha/beta pruning optimizes this algorithm by preventing redundant branch traversals.
+# Once beta is <= to alpha at any level, MinMax will stop traversing adjacent GameTrees
+# And promote the most optimial GameTree at that level.
+# Since GameTree#next_game_trees is implemented optimally by filtering out equivalent GameTrees, it
+# Improves the performance of MinMax.
+# An additional optimization would be to sort GameTrees by their ratings in ascending order.
+# This would allow MinMax to establish the final beta GameTree rating much quicker, and prune more branches
+# Due to the ascending ordering of the GameTrees.
+# MinMax's worst case runtime is O(n!)
+# For more details: https://www.geeksforgeeks.org/minimax-algorithm-in-game-theory-set-4-alpha-beta-pruning/
+
+module Model
+  class MoveStrategy
+    EvaluatedBoard = Struct.new(:game_tree, :rating)
+
+    def select_move(game_tree)
+      @team = game_tree.current_team
+      evaluated_game_tree = min_max(game_tree, 9, true, -Float::INFINITY, Float::INFINITY)
+
+      evaluated_game_tree.game_tree.previous_move
+    end
+
+    private
+
+    def min_max(game_tree, cut_off, maximizing, alpha, beta)
+      return evaluated_game_tree(game_tree) if cut_off.zero? || game_tree.complete?
+
+      cut_off -= 1
+
+      if maximizing
+        max(game_tree.next_game_trees, cut_off, alpha, beta)
+      else
+        min(game_tree.next_game_trees, cut_off, alpha, beta)
+      end
+    end
+
+    def max(game_trees, cut_off, alpha, beta)
+      curr_eval_game_tree = nil
+
+      game_trees.each do |game_tree|
+        eval_game_tree = min_max(game_tree, cut_off, false, alpha, beta)
+
+        eval_game_tree.game_tree = game_tree
+
+        alpha = eval_game_tree.rating if eval_game_tree.rating > alpha
+
+        curr_eval_game_tree = eval_game_tree if
+          curr_eval_game_tree.nil? || eval_game_tree.rating > curr_eval_game_tree.rating
+
+        break if beta <= alpha
+      end
+
+      curr_eval_game_tree
+    end
+
+    def min(game_trees, cut_off, alpha, beta)
+      curr_eval_game_tree = nil
+
+      game_trees.each do |game_tree|
+        eval_game_tree = min_max(game_tree, cut_off, true, alpha, beta)
+
+        eval_game_tree.game_tree = game_tree
+
+        beta = eval_game_tree.rating if eval_game_tree.rating < beta
+
+        curr_eval_game_tree = eval_game_tree if
+          curr_eval_game_tree.nil? || eval_game_tree.rating < curr_eval_game_tree.rating
+
+        break if beta <= alpha
+      end
+
+      curr_eval_game_tree
+    end
+
+    def evaluated_game_tree(game_tree)
+      EvaluatedBoard.new(game_tree, game_tree.rating(@team))
+    end
+  end
+end

data/lib/tic_tac_toe/model/piece.rb

@@ -0,0 +1,15 @@
+module Model
+  class Piece
+    attr_reader :name
+    attr_accessor :team
+
+    def initialize(name, move_klass)
+      @name = name
+      @move_klass = move_klass
+    end
+
+    def moves(board)
+      @move_klass.generate_moves(self, board)
+    end
+  end
+end

data/lib/tic_tac_toe/model/team.rb

@@ -0,0 +1,29 @@
+module Model
+  class Team
+    attr_reader :name, :move_strategy, :pieces
+
+    def initialize(args)
+      raise ArgumentError, 'empty pieces array' if args[:pieces].empty?
+
+      @name = args[:name]
+      @move_strategy = args[:move_strategy]
+      @pieces = args[:pieces]
+
+      @pieces.each { |p| p.team = self }
+    end
+
+    def selected_piece
+      @pieces[0]
+    end
+
+    def computer?
+      !@move_strategy.nil?
+    end
+
+    def available_moves(board)
+      @pieces.each_with_object([]) do |piece, moves|
+        moves.concat(piece.moves(board))
+      end
+    end
+  end
+end