mine-sweeper 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3cfd499cad7b89c5d6494534c4db66233db79595
+  data.tar.gz: a9a393f72e5bf30c3c3b1ecf7be27738134f2498
+SHA512:
+  metadata.gz: 0bb0db5ea31b6ee7df11abe9b2fef4a701b6dee305d0409d934997694814999e2ac555b5263fb03e55ba0b58828ae973363bd6f9e0d1c85813b64c9fb15bd178
+  data.tar.gz: 56fff36c0331077938b32900a1daf7e32d13b539a18f50228e3393f1a3ffc0a38e3f40d940fc35c27763c920cba80e2c5e737af72a6ac62e13e1635151749dcf

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Dan Berger
+
+MIT License
+
+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,52 @@
+# MineSweeper
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mine-sweeper'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mine-sweeper
+
+## Usage
+
+#### Launch Game
+
+Play MineSweeper in pry or irb with only two commands:
+
+    $ require 'mine-sweeper'
+    $ MineSweeper::Game.new
+
+#### Commands
+
+Every turn you will be guided to select a row, a column and a command.
+
+  **'C'** to clear a space. This will not work if the coordinates are flagged.
+
+  **'A'** to auto-clear around the coordinates. This only works if
+    (1) the coordinates are already cleared and
+    (2) the number of adjacent flags matches the number of adjacent mines.
+
+  **'F'** to flag a space as a mine.
+
+  **'U'** to un-flag, or remove a flag.
+
+The number next to the '⚑' symbol shows you how many flags are left to place."
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/mine-sweeper/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,2 @@
+require "bundler/gem_tasks"
+

data/lib/mine-sweeper.rb

@@ -0,0 +1,19 @@
+require "mine-sweeper/version"
+require "mine-sweeper/cell"
+require "mine-sweeper/minefield"
+require "mine-sweeper/turn"
+require "mine-sweeper/game_helper"
+
+module MineSweeper
+  class Game
+    def initialize
+      @mines = Minefield.new
+      intro
+      loop do
+        print_game_board
+        take_a_turn
+        check_for_game_end
+      end
+    end
+  end
+end

data/lib/mine-sweeper/cell.rb

@@ -0,0 +1,66 @@
+module MineSweeper
+
+  class Cell
+
+    attr_reader :mine, :cleared, :flagged, :adjacent_mines
+
+    def initialize
+      @mine = false
+      @cleared = false
+      @flagged = false
+      @adjacent_mines = 0
+    end
+
+    # This ends the game!
+    def exploded?
+      mine && cleared
+    end
+
+    def place_mine
+      @mine = true
+    end
+
+    def count_adjacent_mine
+      @adjacent_mines += 1
+    end
+
+    def clear
+      @cleared = true unless flagged
+    end
+
+    def flag
+      @flagged = true unless cleared
+    end
+
+    def unflag
+      @flagged = false
+    end
+
+    def to_s
+      if cleared
+        cleared_string_states
+      else
+        uncleared_string_states
+      end
+    end
+
+    private
+
+    def cleared_string_states
+      return "✷" if exploded?
+      if adjacent_mines == 0
+        " "
+      else
+        adjacent_mines.to_s
+      end
+    end
+
+    def uncleared_string_states
+      if flagged
+        "⚑"
+      else
+        "█"
+      end
+    end
+  end
+end

data/lib/mine-sweeper/game_helper.rb

@@ -0,0 +1,48 @@
+require_relative 'minefield'
+require_relative 'turn'
+
+module MineSweeper
+  class Game
+
+    private
+
+    def intro
+      print "welcome to\nMINESWEEPER\n\nCOMMANDS:\n'C' to clear\n'A' to auto-clear\n'F' to flag\n'U' to un-flag\nThe ⚑ shows you how many flags are left"
+    end
+
+    def print_game_board
+      puts "⚑ #{@mines.unflagged_mines}"
+      @mines.render
+    end
+
+    def take_a_turn
+      turn = Turn.new
+      @mines.take_turn(turn.message)
+    end
+
+    def check_for_game_end
+      game_over_sequence if @mines.game_over?
+    end
+
+    def game_over_sequence
+      if @mines.won?
+        winning_sequence
+      else
+        losing_sequence
+      end
+      exit
+    end
+
+    def winning_sequence
+      @mines.flag_remaining_mines
+      print_game_board
+      puts "CONGRATULATIONS!"
+    end
+
+    def losing_sequence
+      @mines.blow_up_board
+      print_game_board
+      puts "BOOM! YOU LOST."
+    end
+  end
+end

data/lib/mine-sweeper/minefield.rb

@@ -0,0 +1,208 @@
+require_relative 'cell'
+
+module MineSweeper
+
+  class Minefield
+
+    attr_reader :size, :field
+
+    def initialize(size = 10)
+      set_field_size(size)
+      create_field_with_attributes
+    end
+
+    def render
+      field.each do |row|
+        row.each { |cell| print cell }
+        print "\n"
+      end
+      nil
+    end
+
+    def take_turn(turn)
+      row = turn[:row]
+      column = turn[:column]
+      action = turn[:action]
+      take_action(row, column, action)
+    end
+
+    # GAME ENDING SCENARIOS
+
+    def lost?
+      field.flatten.any? { |cell| cell.exploded? }
+    end
+
+    def blow_up_board
+      field.flatten.each do |cell|
+        cell.clear if cell.mine
+      end
+    end
+
+    def won?
+      uncleared_cells == number_of_mines
+    end
+
+    def flag_remaining_mines
+      field.flatten.each do |cell|
+        cell.flag if cell.mine
+      end
+    end
+
+    def game_over?
+      lost? || won?
+    end
+
+    # PUBLIC BOARD INFORMATION
+
+    def number_of_mines
+      field.flatten.count { |cell| cell.mine }
+    end
+
+    def number_of_flags
+      field.flatten.count { |cell| cell.flagged }
+    end
+
+    def unflagged_mines
+      number_of_mines - number_of_flags
+    end
+
+    def uncleared_cells
+      field.flatten.count { |cell| !(cell.cleared) }
+    end
+
+    private
+
+    # INITIALIZE HELPERS
+
+    def set_field_size(size)
+      if size.class == Fixnum
+        @size = size
+      else
+        raise 'Please enter an integer.'
+      end
+    end
+
+    def create_field_with_attributes
+      @field = Array.new(size){ Array.new(size){ Cell.new } }
+      generate_mines
+      generate_adjacent_mine_counts
+    end
+
+    def mine_calculator
+      if size < 20
+        9
+      else
+        100
+      end
+    end
+
+    def generate_mines
+      mines_left = mine_calculator
+      until mines_left == 0
+        row = rand(size)
+        col = rand(size)
+        unless field[row][col].mine
+          field[row][col].place_mine
+          mines_left -= 1
+        end
+      end
+    end
+
+    def generate_adjacent_mine_counts
+      field.each_with_index do |row, row_num|
+        row.each_with_index do |cell, col_num|
+          if cell.mine
+            neighbor_cells(row_num,col_num).each do |neighbor|
+              neighbor.count_adjacent_mine
+            end
+          end
+        end
+      end
+    end
+
+    # TAKE TURN HELPERS
+
+    def take_action(row, column, action)
+      cell = field[row][column]
+      case action
+      when "A"
+        auto_clear(row,column)
+      when "C"
+        clear_with_zero_cascade(row,column)
+      when "F"
+        cell.flag if unflagged_mines > 0
+      when "U"
+        cell.unflag
+      end
+    end
+
+    # SMART CLEARING
+
+    def auto_clear(row,col)
+      if already_cleared?(row,col) && flags_match_mines?(row,col)
+        valid_neighbor_coordinates(row,col).each do |cell|
+          row,col = cell[0],cell[1]
+          clear_with_zero_cascade(row,col)
+        end
+      end
+    end
+
+    def clear_with_zero_cascade(target_row,target_column)
+      target_cell = field[target_row][target_column]
+      target_cell.clear
+      if target_cell.adjacent_mines == 0
+        valid_neighbor_coordinates(target_row,target_column).each do |cell|
+          row,col = cell[0],cell[1]
+          unless field[row][col].cleared
+            clear_with_zero_cascade(cell[0],cell[1])
+          end
+        end
+      end
+    end
+
+    def already_cleared?(row,col)
+      field[row][col].cleared
+    end
+
+    def flags_match_mines?(row,col)
+      count_nearby_flags(row,col) == field[row][col].adjacent_mines
+    end
+
+    def count_nearby_flags(row,col)
+      neighbor_cells(row,col).count { |cell| cell.flagged }
+    end
+
+    # FINDING NEIGHBOR CELLS HELPERS
+
+    def valid_rows(row)
+      rows = [row]
+      rows << (row - 1) unless row == 0
+      rows << (row + 1) unless row == (size - 1)
+      rows
+    end
+
+    def valid_cols(col)
+      cols = [col]
+      cols << (col - 1) unless col == 0
+      cols << (col + 1) unless col == (size - 1)
+      cols
+    end
+
+    def valid_neighbor_coordinates(row,col)
+      coords =  valid_rows(row).each_with_object([]) do |row, nearby|
+                  valid_cols(col).each do |col|
+                    nearby << [row,col]
+                  end
+                end
+      coords - [[row,col]]
+    end
+
+    def neighbor_cells(row,col)
+      valid_neighbor_coordinates(row,col).each_with_object([]) do |cell,neighbors|
+        neighbor_row = cell[0]
+        neighbor_col = cell[1]
+        neighbors << field[neighbor_row][neighbor_col]
+      end
+    end
+  end
+end

data/lib/mine-sweeper/turn.rb

@@ -0,0 +1,36 @@
+module MineSweeper
+
+  class Turn
+
+    attr_reader :action
+
+    def initialize
+      print "which row?\n > "
+      @row = gets.chomp.to_i
+      print "which column?\n > "
+      @column = gets.chomp.to_i
+      @action = "x"
+      until action_is_valid?
+        print "which action?\n > "
+        @action = gets.chomp.upcase
+        print "that is not a valid action" unless action_is_valid?
+      end
+    end
+
+    def message
+      { row: @row,
+        column: @column,
+        action: @action }
+    end
+
+    private
+
+    def action_is_valid?
+      valid_actions.include? action
+    end
+
+    def valid_actions
+      ["A","C","F","U"]
+    end
+  end
+end

data/lib/mine-sweeper/version.rb

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

data/mine-sweeper.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mine-sweeper/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mine-sweeper"
+  spec.version       = MineSweeper::VERSION
+  spec.authors       = ["Dan Berger"]
+  spec.email         = ["dsberger@gmail.com"]
+  spec.summary       = %q{A CLI Minesweeper clone}
+  spec.description   = %q{Remember Minesweeper? It's like that only clunkier.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: mine-sweeper
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dan Berger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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: Remember Minesweeper? It's like that only clunkier.
+email:
+- dsberger@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/mine-sweeper.rb
+- lib/mine-sweeper/cell.rb
+- lib/mine-sweeper/game_helper.rb
+- lib/mine-sweeper/minefield.rb
+- lib/mine-sweeper/turn.rb
+- lib/mine-sweeper/version.rb
+- mine-sweeper.gemspec
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: A CLI Minesweeper clone
+test_files: []