games_bfox 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ff3dcb410111396a3ce03ef859fb52d70a5b5d5d
+  data.tar.gz: 269d8193da9129cf52efd370764abc318d376de6
+SHA512:
+  metadata.gz: cabca83cb240420badc2e59c271f6ef5de2c9ac9b2825fedbf65ef2f20d14b14f3ac9a9593e709381bdb55a2f38c86217b65134aa3d7eb36856e566b046f0f73
+  data.tar.gz: 648ab711ef30fc5ba0f7b9bc3fdb082bfbc761e4e03c9cf67f90c9ef5504533042bf3774d121d93592402cbd348ff6984fdea9851d996d2dbc84346a23ca1d74

data/.gitignore

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

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--format documentation
+--color

data/.travis.yml

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

data/Gemfile

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

data/README.md

@@ -0,0 +1,36 @@
+# Games
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/games`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'games'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install games
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also 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`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/games.
+

data/Rakefile

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

data/exe/mastermind

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+#below line requires mastermind which runs program
+require "games/mastermind"
+
+Mastermind.run
+

data/exe/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/exe/tictactoe

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+#below line requires tictactoe which runs program
+require "games/tictactoe"
+
+TicTacToe.run
+

data/games.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+games = File.expand_path('../lib/games', __FILE__)
+mastermind = File.expand_path('../lib/games/mastermind', __FILE__)
+shared = File.expand_path('../lib/games/shared', __FILE__)
+tictactoe = File.expand_path('../lib/games/tictactoe', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$LOAD_PATH.unshift(games) unless $LOAD_PATH.include?(games)
+$LOAD_PATH.unshift(mastermind) unless $LOAD_PATH.include?(mastermind)
+$LOAD_PATH.unshift(shared) unless $LOAD_PATH.include?(shared)
+$LOAD_PATH.unshift(tictactoe) unless $LOAD_PATH.include?(tictactoe)
+require 'games/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "games_bfox"
+  spec.version       = Games::VERSION
+  spec.authors       = ["Brett Fox"]
+  spec.email         = ["brettfox11@gmail.com"]
+
+  spec.summary       = %q{Play tic tac toe and mastermind on the command line}
+  spec.description   = %q{In order to play, download the gem, and type \"tictactoe\" or \"mastermind\" at your terminal.}
+  spec.homepage      = "https://github.com/brett11/games"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.6"
+  spec.add_development_dependency 'pry', '~> 0.10.4'
+  spec.add_development_dependency 'logging', '~> 2.2', '>= 2.2.2'
+end

data/lib/games/mastermind/board.rb

@@ -0,0 +1,43 @@
+module MM
+  class Board
+    attr_accessor :number_of_rows, :number_of_cols, :pegs, :result_pegs
+
+    def initialize(args = {})
+      @number_of_rows = args[:number_of_rows]
+      @number_of_cols = args[:number_of_cols]
+      @pegs = args[:pegs]
+      @result_pegs = args[:result_pegs]
+    end
+
+    def change_peg(row, col, new_value)
+      peg_to_change = retrieve_peg(row, col)
+      peg_to_change.change_value(new_value)
+    end
+
+    def display_values
+      pegs.display_values
+    end
+
+    def result_values
+      result_pegs.display_values
+    end
+
+    def pegs_current_row(number_of_turns_taken)
+      pegs.current_row(number_of_turns_taken)
+    end
+
+    def result_pegs_current_row(number_of_turns_taken)
+      result_pegs.current_row(number_of_turns_taken)
+    end
+
+    private
+      def retrieve_peg(row, col)
+        return pegs.retrieve_peg(row, col)
+      end
+
+      #result_pegs is an instance of pegs
+      def retrieve_result_peg(row, col)
+        return result_pegs.retrieve_peg(row,col)
+      end
+  end
+end

data/lib/games/mastermind/board_builder.rb

@@ -0,0 +1,9 @@
+require_relative 'pegs_factory'
+
+module MM
+  class BoardBuilder
+    def generate_empty_board(config)
+      Board.new(number_of_rows: config.number_of_rows, number_of_cols: config.number_of_cols, pegs: PegsFactory.build_empty_pegs(config.number_of_rows, config.number_of_cols), result_pegs: PegsFactory.build_empty_pegs(config.number_of_rows, config.number_of_cols) )
+    end
+  end
+end

data/lib/games/mastermind/board_presenter_terminal.rb

@@ -0,0 +1,69 @@
+module MM
+  class BoardPresenterTerminal
+    attr_accessor :board
+
+    def present_board(board)
+      @board = board
+      present_board_and_results(self.board)
+    end
+
+    def present_board_only(board)
+      #board.display_values will return multidimensional array
+      display_values.each_with_index do |row, row_number|
+        row.each_with_index do |display_value, index|
+          #http://www.evc-cit.info/cit020/beginning-programming/chp_04/file_printf.html
+          if display_value == nil
+            print "  "
+          else
+            printf "%2s", display_value
+          end
+
+          print " | " unless index == (row.size - 1)
+        end
+        print "\n"
+        puts "_"*(row.size * 5) unless row_number.equal? (number_of_rows - 1)
+      end
+    end
+
+    def present_board_and_results(board)
+      @board = board
+
+      print "     Guess" + "                    " +"Result"
+      print "\n"
+      puts "-" * 40
+      guesses_and_results = display_values.zip(result_values)
+      #board.display_values will return multidimensional array
+      guesses_and_results.each do |values|
+        #values is either display_values or result_values
+        values.each_with_index do |row, row_number|
+          row.each_with_index do |display_value, index|
+            #http://www.evc-cit.info/cit020/beginning-programming/chp_04/file_printf.html
+            if display_value == nil
+              print "  "
+            else
+              printf "%2s", display_value
+            end
+
+            print " | " unless index == (row.size - 1)
+          end
+          print "       " unless row.equal? values.last
+        end
+        print "\n"
+        puts "_"*(values.size * 20) unless values.equal? guesses_and_results.last
+      end
+    end
+
+    def display_values
+      board.display_values
+    end
+
+    def result_values
+      board.result_values
+    end
+
+    def number_of_rows
+      board.number_of_rows
+    end
+
+  end
+end

data/lib/games/mastermind/colors.rb

@@ -0,0 +1,14 @@
+module MM
+  class Colors
+    def self.key
+      {
+        1 => :red,
+        2 => :green,
+        3 => :blue,
+        4 => :orange,
+        5 => :yellow,
+        6 => :brown
+      }
+    end
+  end
+end

data/lib/games/mastermind/game.rb

@@ -0,0 +1,64 @@
+require_relative '../shared/game'
+
+module MM
+  class Game < Shared::Game
+    attr_accessor :code_setter, :secret_code, :guess_evaluator, :current_guess, :current_result, :won_flag
+
+    def local_setup
+      self.code_setter = config.code_setter
+      self.secret_code = config.secret_code
+      print secret_code
+      print "\n"
+      self.guess_evaluator = MM::GuessEvaluator.new
+      self.current_guess = []
+      self.current_result = []
+      self.won_flag = false
+    end
+
+    def over?
+      won? || over_with_no_winner?
+    end
+
+    def over_with_no_winner?
+      number_of_turns_taken >= 12
+    end
+
+    def won?
+      #depends on evaluate_guess returning an array of all "X"s for perfect guess
+      if won_flag
+        return true
+      end
+
+      if current_result == ("X" * number_of_cols).chars
+        self.won_flag = true
+        true
+      else
+        false
+      end
+    end
+
+    def change_peg(row, col, new_value)
+      board.change_peg(row, col, new_value)
+    end
+
+    def evaluate_guess(secret_code, guess)
+      guess_evaluator.evaluate_guess(secret_code, guess)
+    end
+
+    def pegs_current_row
+      board.pegs_current_row(number_of_turns_taken)
+    end
+
+    def result_pegs_current_row
+      board.result_pegs_current_row(number_of_turns_taken)
+    end
+
+    def number_of_cols
+      board.number_of_cols
+    end
+
+    def set_secret_code
+      config.set_secret_code
+    end
+  end
+end

data/lib/games/mastermind/game_config.rb

@@ -0,0 +1,48 @@
+module MM
+  class GameConfig
+    attr_accessor :input_helper
+
+    attr_accessor :player_1_name
+    attr_accessor :code_setter
+    attr_accessor :secret_code
+    attr_accessor :number_of_rows
+    attr_accessor :number_of_cols
+
+    def initialize(input_helper)
+      @input_helper = input_helper
+      @number_of_rows = 12
+      @number_of_cols = 4
+
+    end
+
+    def one_time_setup
+      self.player_1_name = input_helper.get_player_1_name
+      #defaults set above. uncomment to ask the player to choose
+      # self.number_of_rows = input_helper.get_number_of_rows
+      # self.number_of_cols = input_helper.get_number_of_cols
+    end
+
+    def every_time_setup
+      self.code_setter = input_helper.computer_or_human_code_setter_inquiry(player_1_name)
+      self.secret_code = get_secret_code
+    end
+
+    def get_secret_code
+      code = nil
+      if code_setter == :human
+        code = input_helper.get_secret_code_from_user(player_1_name)
+      elsif code_setter == :computer
+        code = set_secret_code
+      end
+      code
+    end
+
+    def set_secret_code
+      secret_code = []
+      4.times do
+        secret_code.push((1..6).to_a.sample)
+      end
+      secret_code
+    end
+  end
+end

data/lib/games/mastermind/game_resetter.rb

@@ -0,0 +1,19 @@
+module MM
+  class GameResetter
+    attr_accessor :game
+
+    def reset_game(game)
+      @game = game
+      reset_board
+      game.number_of_turns_taken = 0
+      game.won_flag = false
+      game.secret_code = game.set_secret_code
+      game.current_guess = []
+      game.current_result = []
+    end
+
+    def reset_board
+      game.board = game.generate_empty_board(game.config)
+    end
+  end
+end

data/lib/games/mastermind/game_state_changer.rb

@@ -0,0 +1,41 @@
+module MM
+  class GameStateChanger
+    attr_accessor :game
+
+    def change_game_state(guess, game)
+      @game = game
+      game.current_guess = guess
+      game.current_result = game.evaluate_guess(secret_code, current_guess)
+      change_pegs(guess, game.current_result)
+      if !game.won?
+        game.move_forward_one_turn
+      end
+    end
+
+    def change_pegs(guess, current_result)
+      current_row.each_with_index do |peg, index|
+        peg.change_value(guess[index])
+      end
+
+      result_pegs_current_row.each_with_index do |peg, index|
+        peg.change_value(current_result[index])
+      end
+    end
+
+    def current_row
+      game.pegs_current_row
+    end
+
+    def result_pegs_current_row
+      game.result_pegs_current_row
+    end
+
+    def secret_code
+      game.secret_code
+    end
+
+    def current_guess
+      game.current_guess
+    end
+  end
+end

data/lib/games/mastermind/guess_evaluator.rb

@@ -0,0 +1,85 @@
+require_relative '../shared/array_iterator'
+require 'set.rb'
+
+module MM
+  class GuessEvaluator
+    attr_accessor :secret_code
+    attr_accessor :guess
+    attr_accessor :result
+
+    # returns "XXXX" if perfect guess. returns XXO, for example, if two perfect guesses and one right digit but wrong place
+    def evaluate_guess(secret_code, guess)
+      @secret_code = Marshal.load(Marshal.dump(secret_code))
+      @guess = Marshal.load(Marshal.dump(guess))
+      #default when game starts is to have empty current_guess array
+      if guess.empty?
+        return []
+      end
+      @result = find_result
+    end
+
+    def find_result
+      resX = find_exact_matches
+      resO = find_partial_matches
+      resX.concat resO
+    end
+
+    def find_exact_matches
+      resX = []
+      set_of_matched_indexes = Set.new
+      guess.each_with_index do |element, index|
+        if element == secret_code[index]
+          resX.push ("X")
+          set_of_matched_indexes.add(index)
+        end
+      end
+      delete_elements_already_matched(set_of_matched_indexes)
+      resX
+    end
+
+    def delete_elements_already_matched(set_of_matched_indexes)
+      secret_code.delete_if.with_index { |_, index| set_of_matched_indexes.include? index }
+      guess.delete_if.with_index { |_, index| set_of_matched_indexes.include? index }
+    end
+
+    def find_partial_matches
+      resO = []
+      return resO if secret_code.empty? || guess.empty?
+      secret_code.sort!
+      guess.sort!
+
+      secret_code_iterator = Shared::ArrayIterator.new(secret_code)
+      guess_iterator = Shared::ArrayIterator.new(guess)
+
+      #get first elements from enums
+      code_element = secret_code_iterator.next_item
+      guess_element = guess_iterator.next_item
+
+
+      while true
+        if guess_element == code_element
+          resO.push("O")
+          if secret_code_iterator.has_next? && guess_iterator.has_next?
+            code_element = secret_code_iterator.next_item
+            guess_element = guess_iterator.next_item
+          else
+            break
+          end
+        elsif guess_element > code_element
+          if secret_code_iterator.has_next?
+            code_element = secret_code_iterator.next_item
+          else
+            break
+          end
+        else
+          if guess_iterator.has_next?
+            guess_element = guess_iterator.next_item
+          else
+            break
+          end
+        end
+      end
+      resO
+    end
+  end
+end

data/lib/games/mastermind/input_helper.rb

@@ -0,0 +1,54 @@
+require_relative '../shared/input_helper'
+
+module MM
+  class InputHelper < Shared::InputHelper
+    def computer_or_human_code_setter_inquiry(name)
+      user_choice = get_user_input("#{name}, please enter \"1\" if you would like to be the code-guesser. Enter \"2\" if you would like to set the code and have the computer guess.", "Invalid entry. Please enter either 1(computer picks code) or 2 (you pick code)") do |input|
+        input == 1 || input == 2
+      end
+      if user_choice == 1
+        return :computer
+      elsif user_choice == 2
+        return :human
+      end
+    end
+
+    def get_secret_code_from_user(name)
+      user_choice = get_user_input("#{name}, please enter a secret code consisting of four numbers that each correspond to a color. Do not separate with punctuation. The computer will try to guess this code.", "Please re-enter a secret code, using only 4 numbers, 1 through 6.") do |input|
+        input.to_s =~ /^[1-6]{4}$/
+      end
+      user_choice.to_s.chars.map(&:to_i)
+    end
+
+    def get_player_choice(game)
+      user_choice = get_user_input("#{game.current_player_name}, please enter a secret code consisting of 4 numbers that correspond to the color of your guess. Do not separate with punctuation.", "Please re-enter a secret code guess, using exactly 4 numbers, each being a digit 1 through 6.") do |input|
+        input.to_s =~ /^[1-6]{4}$/
+      end
+      user_choice.to_s.chars.map(&:to_i)
+    end
+
+    def draw_prompt
+      io.present_with_new_line("No such luck! Please try again.")
+    end
+
+    def winning_prompt(current_player_name)
+      io.present_with_new_line("#{current_player_name} wins!")
+    end
+
+    def no_winner_prompt
+      io.present_with_new_line("Game over!")
+    end
+
+    def get_number_of_rows
+      get_user_input("Please choose how many rows of pegs you would like, from 4 to 12.", "Please choose a number between 4 and 12.") do |input|
+        input.to_i >=4 && input.to_i <=12
+      end
+    end
+
+    def get_number_of_cols
+      get_user_input("Please choose how many pegs you would like in each row, from 4 to 6.", "Please choose a number between 4 and 6.") do |input|
+        input.to_i >=4 && input.to_i <=6
+      end
+    end
+  end
+end

data/lib/games/mastermind/move_generator.rb

@@ -0,0 +1,46 @@
+module MM
+  class MoveGenerator
+
+    attr_accessor :game
+
+    def get_player_choice(game)
+      @game = game
+      get_move
+    end
+
+    def get_move
+      if human?
+        input_helper.get_player_choice(game)
+      elsif computer?
+        input_helper.computer_choosing_graphic
+        computer_move
+      end
+    end
+
+    def computer_move
+      secret_code = []
+      4.times do
+        secret_code.push((1..6).to_a.sample)
+      end
+      secret_code
+    end
+
+
+    def current_player
+      game.current_player
+    end
+
+    def input_helper
+      game.input_helper
+    end
+
+    def human?
+      game.current_player_human?
+    end
+
+    def computer?
+      game.current_player_computer?
+    end
+  end
+end
+

data/lib/games/mastermind/peg.rb

@@ -0,0 +1,15 @@
+module MM
+  class Peg
+    attr_accessor :display_value, :row, :col
+
+    def initialize(args)
+      @display_value = args.fetch(:display_value, nil)
+      @row = args[:row]
+      @col = args[:col]
+    end
+
+    def change_value(new_value)
+      self.display_value = new_value
+    end
+  end
+end