mastermind-game 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b6d5bc9c19b85777bb6a3b1a77892337bfb0b75c
+  data.tar.gz: 8e6dede81fcfd1347048900504939e8116fd7ad9
+SHA512:
+  metadata.gz: 3dbaf6735bc410f513e8fdf125ae5d84ddf171cb146c0e885d32778a238a2490f13b1212dcfa213184ecfe3413f67b9b52cb84364f9c6d1d3bc15f1f1d458133
+  data.tar.gz: c237db2c005d129d476a5a754ed67c8a7f5eef43a16aee3a154cd3ea99e5973c51b108446d8ee3b01009e75aba2894e8359d69ced94ade5b938a1f638328f827

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Andur Carr
+
+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,79 @@
+# Mastermind
+
+[Mastermind](https://en.wikipedia.org/wiki/Mastermind_(board_game)) is a two-player board game created in 1970 by [Mordecai Meirowitz](https://en.wikipedia.org/wiki/Mordecai_Meirowitz). This gem provides an API for building this game, as well as a demonstration version that can be run in the console.
+
+In the game, one player is assigned the role of "Code Maker" and the other "Code Breaker". The Code Maker creates a secret code sequence, which is represented by four pegs, each of one of six colors. The Code Breaker then has 12 attempts to determine what the secret code sequence is, with information on how many pegs were matched with the correct color in the correct position or a correct color in an incorrect position.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mastermind-game'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mastermind-game
+
+## Usage
+
+If you are using bundler, a demonstration of this game can be run in the terminal once the gem is installed:
+
+```bash
+$ mastermind
+```
+
+### Game
+
+The `Mastermind::Game` object is the primary point of interaction. Instances of this object contain all the information for a complete game.
+
+```ruby
+# Instantiate a game with a random secret
+game = Mastermind::Game.new
+
+# Prepare a guess
+guess = [:red, :red, :red, :red]
+game.guess(guess)
+
+# Find how many turns there have been
+game.attempts # => 1
+
+# Check if the game is over
+game.over? # => false
+
+# Determine who has won (returns a Player instance)
+game.winner # => nil
+```
+
+### Knuth Algorithm
+
+In 1977, Donald Knuth developed an algorithm by which the correct code can be guessed in at most five turns. An implementation of this algorithm is included with this gem. To make use of it, create a new instance of the Knuth algorithm, supplying a game object:
+
+```ruby
+game = Mastermind::Game.new
+knuth = Mastermind::Knuth.new(game)
+guess = knuth.prepare_guess
+game.guess(guess)
+```
+
+A first guess can be obtained almost instantly. However, due to this problem being NP-Complete, the second guess may take several seconds. Follow-on guesses will take less time due to fewer possibilities remaining.
+
+## 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/lamarseillaise/mastermind.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

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/console

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

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mastermind"
+
+Mastermind::Console.run

data/bin/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/lib/mastermind.rb

@@ -0,0 +1,15 @@
+require "mastermind/version"
+require "mastermind/game"
+require "mastermind/game/piece"
+require "mastermind/game/code"
+require "mastermind/game/turn"
+require "mastermind/player"
+require "mastermind/player/computer"
+require "mastermind/player/human"
+require "mastermind/console"
+require "mastermind/console/view"
+require "mastermind/console/controller"
+require "mastermind/knuth"
+
+module Mastermind
+end

data/lib/mastermind/console.rb

@@ -0,0 +1,9 @@
+module Mastermind
+  module Console
+    def self.run
+      controller = Controller.new
+      controller.setup
+      loop { controller.start_game }
+    end
+  end
+end

data/lib/mastermind/console/controller.rb

@@ -0,0 +1,64 @@
+module Mastermind
+  module Console
+    class Controller
+      def setup
+        puts View.introduction
+        print "How many players will there be? "
+        number_of_players = Player::Human.get_input.to_i
+
+        @player1 = get_player(1)
+        @player2 = get_player(2) if number_of_players > 1
+        @player2 ||= Player::Computer.new(name: "Computer")
+      end
+
+      def start_game
+        codebreaker = get_codebreaker
+        codemaker = (codebreaker == @player1) ? @player2 : @player1
+
+        play Game.new(
+          secret: get_secret_from(codemaker),
+          codemaker: codemaker,
+          codebreaker: codebreaker
+        )
+
+        puts "\n\n"
+      end
+
+      def play(game)
+        width = game.secret_length
+        puts "#{game.codebreaker.name} must guess the code."
+        puts View.grading_scheme
+        puts View.top_border(width: width)
+        make_guess(game) until game.over?
+        puts View.bottom_border(width: width)
+        puts "#{game.winner.name} wins! (#{game.attempts} guesses)"
+      end
+
+
+      private
+
+      def get_player(number)
+        print "What is Player #{number}'s name? "
+        Player::Human.new(name: Player::Human.get_input)
+      end
+
+      def get_codebreaker
+        puts "Who will be the code breaker?\n1. #{@player1.name}\n2. #{@player2.name}"
+        (selection = Player::Human.get_input.to_i) until (1..2) === selection
+        [@player1, @player2][selection - 1]
+      end
+
+      def get_secret_from(codemaker)
+        puts View.color_codes
+        puts "#{codemaker.name}: What will the secret code be?" if codemaker.is_a? Player::Human
+        codemaker.get_code(length: 4)
+      end
+
+      def make_guess(game)
+        guess = game.codebreaker.get_guess_for(game)
+        game.guess(guess)
+        puts "\r" + View.attempt_line(game.turns.last, width: game.secret_length)
+      end
+    end
+  end
+end

data/lib/mastermind/console/view.rb

@@ -0,0 +1,62 @@
+require "colorize"
+
+module Mastermind
+  module Console
+    class View
+      TL_CORNER = "\u250F"
+      TM_INTER = "\u2533"
+      TR_CORNER = "\u2513"
+      BL_CORNER = "\u2517"
+      BM_INTER = "\u253B"
+      BR_CORNER = "\u251B"
+      HORIZONTAL = "\u2501"
+      SIDE = "\u2503"
+      BLANK = " "
+      PIECE = "\u25CF"
+      EXACT = "\u25CF".red
+      PARTIAL = "\u25CF".white
+
+      def self.introduction
+        "MASTERMIND\n" +
+        "" +
+        "\n"
+      end
+
+      def self.grading_scheme
+        "#{EXACT}: Matched color and position  #{PARTIAL}: Matched color"
+      end
+
+      def self.color_codes
+        Game::Piece::COLORS.map.with_index do |color, idx|
+          "#{idx + 1}: #{piece_icon(color)}"
+        end.join("  ") + "  q: exit"
+      end
+
+      def self.top_border(width: 4)
+        "    " + TL_CORNER + HORIZONTAL * width + TM_INTER + HORIZONTAL * width + TR_CORNER
+      end
+
+      def self.bottom_border(width: 4)
+        "    " + BL_CORNER + HORIZONTAL * width + BM_INTER + HORIZONTAL * width + BR_CORNER
+      end
+
+      def self.attempt_line(turn, width: 4)
+        "#{turn.number}:".ljust(4) +
+        SIDE + guess_bar(turn.guess.sequence) + BLANK * (width - turn.guess.sequence.length) + SIDE +
+        feedback_line(exact: turn.exact, partial: turn.partial, width: width) + SIDE
+      end
+
+      def self.feedback_line(exact: 0, partial: 0, width: 4)
+        EXACT * exact + PARTIAL * partial + BLANK * (width - exact - partial)
+      end
+
+      def self.piece_icon(color)
+        PIECE.colorize(color)
+      end
+
+      def self.guess_bar(sequence)
+        sequence.map { |piece| piece_icon(piece.color) }.join("")
+      end
+    end
+  end
+end

data/lib/mastermind/game.rb

@@ -0,0 +1,50 @@
+module Mastermind
+  class Game
+    attr_reader :turns, :codemaker, :codebreaker, :max_attempts
+
+    def initialize(secret: nil, codemaker: nil, codebreaker: nil)
+      @secret = (secret && Code.from(secret)) || Code.random
+      @turns = []
+      @codemaker = codemaker || Player.new(name: "AbstractCodemaker")
+      @codebreaker = codebreaker || Player.new(name: "AbstractCodebreaker")
+      @max_attempts = 12
+    end
+
+    def attempts
+      turns.length
+    end
+
+    def secret_length
+      @secret.length
+    end
+
+    def guess(guess_sequence)
+      code = Code.from(guess_sequence)
+      @turns << Turn.new(
+        guess: code, number: attempts + 1,
+        exact: @secret.exact_matches_with(code),
+        partial: @secret.partial_matches_with(code)
+      )
+    end
+
+    def over?
+      max_attempts_reached? || code_guessed?
+    end
+
+    def winner
+      return codebreaker if code_guessed?
+      return codemaker if max_attempts_reached?
+    end
+
+
+    private
+
+    def max_attempts_reached?
+      attempts >= max_attempts
+    end
+
+    def code_guessed?
+      turns.first(max_attempts).any? { |turn| turn.guess == @secret }
+    end
+  end
+end

data/lib/mastermind/game/code.rb

@@ -0,0 +1,62 @@
+module Mastermind
+  class Game
+    class Code
+      attr_reader :sequence
+
+      def self.random(number_of_pieces = 4)
+        sequence = Array.new(number_of_pieces) { Piece.new }
+        new(sequence: sequence)
+      end
+
+      def self.from(colors)
+        new(sequence: colors.map { |color| Piece.new(color: color) })
+      end
+
+      def initialize(sequence:)
+        raise ArgumentError unless sequence.all? { |piece| piece.is_a? Piece }
+        @sequence = sequence
+      end
+
+      def length
+        @sequence.length
+      end
+
+      def color_counts
+        sequence.each_with_object({}) do |piece, counts|
+          counts[piece.color] ||= 0
+          counts[piece.color] += 1
+        end
+      end
+
+      def exact_matches_with(code)
+        raise ArgumentError unless code.is_a? Code
+        sum = 0
+        sequence.each_with_index do |piece, idx|
+          sum += 1 if piece == code.sequence[idx]
+        end
+        sum
+      end
+
+      def color_matches_with(code)
+        raise ArgumentError unless code.is_a? Code
+        other_colors = code.color_counts
+        sum = 0
+        color_counts.each do |color, quantity|
+          sum += [quantity, other_colors[color] || 0].min
+        end
+        sum
+      end
+
+      def partial_matches_with(code)
+        raise ArgumentError unless code.is_a? Code
+        color_matches_with(code) - exact_matches_with(code)
+      end
+
+      def ==(code)
+        code.is_a?(Code) &&
+        length == code.length &&
+        exact_matches_with(code) == length
+      end
+    end
+  end
+end

data/lib/mastermind/game/piece.rb

@@ -0,0 +1,18 @@
+module Mastermind
+  class Game
+    class Piece
+      COLORS = [:red, :green, :blue, :yellow, :white, :black]
+
+      attr_reader :color
+
+      def initialize(color: COLORS.sample)
+        raise ArgumentError.new("Invalid color.") unless COLORS.include?(color)
+        @color = color
+      end
+
+      def ==(piece)
+        piece.is_a?(Piece) && color == piece.color
+      end
+    end
+  end
+end

data/lib/mastermind/game/turn.rb

@@ -0,0 +1,14 @@
+module Mastermind
+  class Game
+    class Turn
+      attr_reader :guess, :exact, :partial, :number
+
+      def initialize(guess:, number:, exact: 0, partial: 0)
+        @guess = guess
+        @exact = exact
+        @partial = partial
+        @number = number
+      end
+    end
+  end
+end

data/lib/mastermind/knuth.rb

@@ -0,0 +1,81 @@
+module Mastermind
+  class Knuth
+    attr_reader :game
+
+    def initialize(game)
+      @game = game
+      # 1. Create the set S of 1296 possible codes
+      @possible_guesses = Game::Piece::COLORS.repeated_permutation(game.secret_length).to_a
+      @set = Game::Piece::COLORS.repeated_permutation(game.secret_length).to_a
+      @game.turns.each { |turn| prune(turn) }
+    end
+
+    def prepare_guess
+      return first_guess if @game.attempts == 0
+      prune(@game.turns.last)
+      return @set.first if @set.length == 1
+      exploratory_guess
+    end
+
+    # 2. Make initial guess of 1122
+    def first_guess
+      first_color = Game::Piece::COLORS.sample
+      second_color = Game::Piece::COLORS.select { |color| color != first_color }.sample
+      Array.new(@game.secret_length) do |position|
+        position < @game.secret_length / 2 ? first_color : second_color
+      end
+    end
+
+    # 5. Choose from the set of guesses with the maximum score, preferring members of S
+    def exploratory_guess
+      max_scoring = maximum_scoring_guesses
+      (max_scoring & @set).sample || max_scoring.sample
+    end
+
+    private
+
+    # 3. Remove from S any code that would not give the same response if the guess were the code.
+    def prune(turn)
+      @set.select! do |combination|
+        code = Game::Code.from(combination)
+        !(turn.guess == code) &&
+        turn.exact   == code.exact_matches_with(turn.guess) &&
+        turn.partial == code.partial_matches_with(turn.guess)
+      end
+
+      @possible_guesses.delete(turn.guess.sequence.map(&:color))
+    end
+
+    # 4. For each possible guess, find the minimum highest match count
+    def minimum_match_count
+      lowest = @set.length
+      @possible_guesses.each do |possible|
+        count = highest_match_count(Game::Code.from(possible))
+        lowest = count if count < lowest
+      end
+      lowest
+    end
+
+    def highest_match_count(guess)
+      highest = 0
+      # for a given number of matches
+      (0..@game.secret_length).each do |matches|
+        # count how many possibilities in S would be retained
+        count = @set.count do |combination|
+          Game::Code.from(combination).color_matches_with(guess) == matches
+        end
+        # track the highest of these
+        highest = count if count > highest
+      end
+      highest
+    end
+
+    # Find the possible guesses for which the highest match count is the minimum match count.
+    def maximum_scoring_guesses
+      min_matches = minimum_match_count
+      @possible_guesses.select do |possible|
+        highest_match_count(Game::Code.from(possible)) == min_matches
+      end
+    end
+  end
+end

data/lib/mastermind/player.rb

@@ -0,0 +1,17 @@
+module Mastermind
+  class Player
+    attr_reader :name
+
+    def initialize(name:)
+      @name = name
+    end
+
+    def get_code
+      raise NotImplementedError.new("Abstract player cannot make code.")
+    end
+
+    def get_guess_for(game)
+      raise NotImplementedError.new("Abstract player cannot guess code.")
+    end
+  end
+end

data/lib/mastermind/player/computer.rb

@@ -0,0 +1,14 @@
+module Mastermind
+  class Player
+    class Computer < Player
+      def get_guess_for(game)
+        @knuth = Knuth.new(game) unless @knuth && @knuth.game == game
+        @knuth.prepare_guess
+      end
+
+      def get_code(length:)
+        Array.new(length) { Game::Piece::COLORS.sample }
+      end
+    end
+  end
+end

data/lib/mastermind/player/human.rb

@@ -0,0 +1,38 @@
+module Mastermind
+  class Player
+    class Human < Player
+      def get_code(length: 4, attempt: nil)
+        sequence = []
+
+        length.times do
+          turn = Game::Turn.new(guess: Game::Code.from(sequence), number: attempt)
+          print "\r" + Console::View.attempt_line(turn, width: length) if attempt
+          color = Game::Piece::COLORS[Human.get_choice(choices: ("1".."6")).to_i - 1]
+          sequence << color
+        end
+
+        sequence
+      end
+
+      def get_guess_for(game)
+        length = game.secret_length
+        get_code(length: length, attempt: game.attempts + 1)
+      end
+
+      def self.get_choice(choices:)
+        begin
+          choice = STDIN.getch
+          exit if choice.start_with?('q') && !puts
+        end until choices.include? choice
+
+        choice
+      end
+
+      def self.get_input
+        input = gets.chomp
+        exit if input.downcase.start_with?('q')
+        input
+      end
+    end
+  end
+end

data/lib/mastermind/version.rb

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

data/mastermind.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mastermind/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mastermind-game"
+  spec.version       = Mastermind::VERSION
+  spec.authors       = ["Andur Carr"]
+  spec.email         = ["carr.andur@gmail.com"]
+
+  spec.summary       = %q{An API for creating the game "Mastermind".}
+  spec.description   = %q{An API for creating the game "Mastermind".}
+  spec.homepage      = "https://github.com/lamarseillaise/mastermind"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.executables   = ["mastermind"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_runtime_dependency "colorize", "~> 0.8.1"
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: mastermind-game
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andur Carr
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+description: An API for creating the game "Mastermind".
+email:
+- carr.andur@gmail.com
+executables:
+- mastermind
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/mastermind
+- bin/setup
+- lib/mastermind.rb
+- lib/mastermind/console.rb
+- lib/mastermind/console/controller.rb
+- lib/mastermind/console/view.rb
+- lib/mastermind/game.rb
+- lib/mastermind/game/code.rb
+- lib/mastermind/game/piece.rb
+- lib/mastermind/game/turn.rb
+- lib/mastermind/knuth.rb
+- lib/mastermind/player.rb
+- lib/mastermind/player/computer.rb
+- lib/mastermind/player/human.rb
+- lib/mastermind/version.rb
+- mastermind.gemspec
+homepage: https://github.com/lamarseillaise/mastermind
+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.5.1
+signing_key: 
+specification_version: 4
+summary: An API for creating the game "Mastermind".
+test_files: []