minesweeper-core 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 996b180c564f2f0c5e1ae87b8e5d2c4664cebbae
+  data.tar.gz: cd87e6240b920aec8d036937b5debf00bdd70e5c
+SHA512:
+  metadata.gz: dd39810b52861ad5c8ab311c8fd88eb3d6d868ffcacf5ab42b4397cdd391b3c5b5a77ceaf7a2f02e45f14153ea01ca490ab4a1373b926a7652935172733a8601
+  data.tar.gz: d3202184311226d28973e6a7a5a18aa9d8729f8a3ddc5e2bce04a8960b0debf7c0aab802eaca19dcabb8bbc3cc60fc08ea578d1c45f976cb0083dc2eb6fe239c

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,20 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea/
+*.gem
+*.iml
+*.ipr
+*.iws
+

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+
+rvm:
+  - 2.0.0

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,30 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features)
+
+## Uncomment to clear the screen before every task
+clearing :on
+
+## Guard internally checks for changes in the Guardfile and exits.
+## If you want Guard to automatically start up again, run guard in a
+## shell loop, e.g.:
+##
+##  $ while bundle exec guard; do echo "Restarting Guard..."; done
+##
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+guard :test do
+  watch(%r{^test/.+_test\.rb$})
+  watch('test/../test_helper.rb')  { 'test' }
+  watch(%r{^lib/(.+)\.rb$}) { |m| "test/#{m[1]}_test.rb" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Sebastien Varlet
+
+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,24 @@
+[![Build Status](https://travis-ci.org/svarlet/minesweeper.svg?branch=master)](https://travis-ci.org/svarlet/minesweeper)
+[![Coverage Status](https://coveralls.io/repos/svarlet/minesweeper/badge.svg?branch=master)](https://coveralls.io/r/svarlet/minesweeper?branch=master)
+
+# Minesweeper
+
+The rules of the minesweeper game are explained there: http://en.wikipedia.org/wiki/Minesweeper_(video_game).
+
+This repository contains a ruby gem that defines the core concepts of a 2D minesweeper game: minefield, cells, mines and the user interactions with the minefield (reveal, flag, unflag). 
+
+Therefore, this gem is not a playable version of the game but if you want to try it, I also built a [terminal frontend](https://github.com/svarlet/minesweeper-console) which uses it.
+
+## Install
+
+Sadly, this gem can't be pushed to rubygems as there are already a pair of gems with the same name. I may or may not rename my gem to fix this. Meanwhile, one can simply do:
+```
+git clone https://github.com/svarlet/minesweeper.git
+cd minesweeper
+rake build install
+```
+
+## Usage
+
+An example of the usage of this library can be found in my terminal based implementation of this game: [svarlet/minesweeper-console](https://github.com/svarlet/minesweeper-console).
+

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+	t.libs << "test"
+	t.test_files = FileList['test/**/*_test.rb']
+	t.verbose = true
+	t.warning = true
+end
+
+task :default => :test

data/lib/minesweeper/core.rb

@@ -0,0 +1,6 @@
+require 'minesweeper/core/version'
+require 'minesweeper/core/minefield'
+require 'minesweeper/core/explosives/explosion_error'
+require 'minesweeper/core/explosives/mine_coordinates_factory'
+require 'minesweeper/core/explosives/mine_layer'
+

data/lib/minesweeper/core/elements/cell.rb

@@ -0,0 +1,57 @@
+require_relative 'cell_state'
+
+module Minesweeper
+  module Core
+    module Elements
+      class Cell
+        # STATES
+        # ---------------------------------------------------------
+        # CURRENT	|	ACTION 	|	STATES			|	ACTION
+        # ---------------------------------------------------------
+        # hidden	|	reveal	|	revealed 		|	trigger
+        # hidden	|	flag 	  |	flagged			|
+        # flagged	|	reveal	|	revealed		|	trigger
+        # flagged	|	unflag	|	hidden			|
+        # ---------------------------------------------------------
+
+        attr_accessor :current_state
+        attr_accessor :mines_around
+
+        def initialize(mine, mines_around = 0)
+          @current_state = CellState::HIDDEN_STATE
+          @mine = mine
+          @mines_around = mines_around
+        end
+
+        def flag
+          current_state.flag(self)
+        end
+
+        def reveal
+          current_state.reveal(self)
+        end
+
+        def unflag
+          current_state.unflag(self)
+        end
+
+        def to_s
+          @current_state == CellState::REVEALED_STATE ? @mines_around.to_s : @current_state.to_s
+        end
+
+        def trigger
+          @mine.trigger
+        end
+
+        def revealed?
+          @current_state == CellState::REVEALED_STATE
+        end
+
+        def flagged?
+          @current_state == CellState::FLAGGED_STATE
+        end
+      end
+    end
+  end
+end
+

data/lib/minesweeper/core/elements/cell_state.rb

@@ -0,0 +1,16 @@
+require_relative 'hidden_state'
+require_relative 'revealed_state'
+require_relative 'flagged_state'
+
+module Minesweeper
+  module Core
+    module Elements
+      module CellState
+        HIDDEN_STATE = HiddenState.new
+        FLAGGED_STATE = FlaggedState.new
+        REVEALED_STATE = RevealedState.new
+      end
+    end
+  end
+end
+

data/lib/minesweeper/core/elements/flagged_state.rb

@@ -0,0 +1,21 @@
+module Minesweeper
+  module Core
+    module Elements
+      class FlaggedState
+        def reveal(cell)
+          cell.current_state = CellState::REVEALED_STATE
+          cell.trigger
+        end
+
+        def unflag(cell)
+          cell.current_state = CellState::HIDDEN_STATE
+        end
+
+        def to_s
+          "F"
+        end
+      end
+    end
+  end
+end
+

data/lib/minesweeper/core/elements/hidden_state.rb

@@ -0,0 +1,21 @@
+module Minesweeper
+  module Core
+    module Elements
+      class HiddenState
+        def reveal(cell)
+          cell.current_state = CellState::REVEALED_STATE
+          cell.trigger
+        end
+
+        def flag(cell)
+          cell.current_state = CellState::FLAGGED_STATE
+        end
+
+        def to_s
+          "H"
+        end
+      end
+    end
+  end
+end
+

data/lib/minesweeper/core/elements/revealed_state.rb

@@ -0,0 +1,12 @@
+module Minesweeper
+  module Core
+    module Elements
+      class RevealedState
+        def to_s
+          "R"
+        end
+      end
+    end
+  end
+end
+

data/lib/minesweeper/core/explosives/explosion_error.rb

@@ -0,0 +1,10 @@
+module Minesweeper
+  module Core
+    module Explosives
+      class ExplosionError < StandardError
+      end
+    end
+  end
+
+end
+

data/lib/minesweeper/core/explosives/mine.rb

@@ -0,0 +1,14 @@
+require_relative 'explosion_error'
+
+module Minesweeper
+  module Core
+    module Explosives
+      class Mine
+        def trigger
+          raise ExplosionError, 'You triggered a mine! Game over.'
+        end
+      end
+    end
+  end
+end
+

data/lib/minesweeper/core/explosives/mine_coordinates.rb

@@ -0,0 +1,27 @@
+module Minesweeper
+  module Core
+    module Explosives
+      class MineCoordinates
+        attr_reader :row_index, :col_index
+
+        def initialize(row_index, col_index)
+          @row_index = row_index
+          @col_index = col_index
+        end
+
+        def ==(other)
+          self.class == other.class &&
+            self.row_index == other.row_index &&
+            self.col_index == other.col_index
+        end
+        alias eql? :==
+
+        def hash
+          [@row_index, @col_index].hash
+        end
+      end
+    end
+  end
+
+end
+

data/lib/minesweeper/core/explosives/mine_coordinates_factory.rb

@@ -0,0 +1,21 @@
+require_relative 'mine_coordinates'
+
+module Minesweeper
+  module Core
+    module Explosives
+      class MineCoordinatesFactory
+        def initialize(random_number_generator)
+          @rng = random_number_generator
+        end
+
+        def create(coordinates_upper_bound)
+          row_index = @rng.rand(coordinates_upper_bound)
+          col_index = @rng.rand(coordinates_upper_bound)
+          MineCoordinates.new(row_index, col_index)
+        end
+      end
+    end
+  end
+
+end
+

data/lib/minesweeper/core/explosives/mine_layer.rb

@@ -0,0 +1,32 @@
+module Minesweeper
+  module Core
+    module Explosives
+      class MineLayer
+        def initialize(a_minefield, a_mine_generator)
+          raise ArgumentError if a_minefield.nil?
+          raise ArgumentError if a_mine_generator.nil?
+          @generator = a_mine_generator
+          @minefield = a_minefield
+        end
+
+        def lay(quantity)
+          laid_mines = []
+          quantity.times do
+            loop do
+              coords = @generator.create(@minefield.row_count)
+              if laid_mines.include?(coords)
+                next
+              else
+                laid_mines << coords
+                @minefield.hide_mine_at(coords.row_index, coords.col_index)
+                break
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+end
+

data/lib/minesweeper/core/explosives/null_mine.rb

@@ -0,0 +1,12 @@
+module Minesweeper
+  module Core
+    module Explosives
+      class NullMine
+        def trigger
+          #do nothing, it's a null mine
+        end
+      end
+    end
+  end
+end
+

data/lib/minesweeper/core/minefield.rb

@@ -0,0 +1,118 @@
+require_relative 'elements/cell'
+require_relative 'explosives/null_mine'
+require_relative 'explosives/explosion_error'
+require_relative 'explosives/mine'
+require_relative 'minefield_solved_error'
+
+module Minesweeper
+  module Core
+    class Minefield
+      attr_reader :row_count
+
+      OFFSETS = [[-1, -1], [-1, 0], [-1, 1], [0, 1], [0, -1], [1, 1], [1, 0], [1, -1]]
+
+      def initialize(row_count)
+        raise ArgumentError unless row_count > 0
+        @row_count = row_count
+        @cells = Array.new(row_count) { Array.new(row_count) { create_non_explosive_cell } }
+        @all_mine_coords = []
+      end
+
+      def create_non_explosive_cell
+        Elements::Cell.new(Explosives::NullMine.new)
+      end
+
+      def to_s
+        @cells.flatten.join
+      end
+
+      def hide_mine_at(row_index, col_index)
+        verify_coordinates_existance(row_index, col_index)
+        create_explosive_cell_at(row_index, col_index)
+        register_mine_at(row_index, col_index)
+        increase_mine_counters_around(row_index, col_index)
+      end
+
+      def verify_coordinates_existance(row_index, col_index)
+        raise RangeError unless cell_exists_at?(row_index, col_index)
+      end
+
+      def create_explosive_cell_at(row_index, col_index)
+        mines_around = mines_adjacent_to(row_index, col_index)
+        @cells[row_index][col_index] = Elements::Cell.new(Explosives::Mine.new, mines_around)
+      end
+
+      def mines_adjacent_to(row_index, col_index)
+        cells_coords_around(row_index, col_index).count { |coords| @all_mine_coords.include?(coords) }
+      end
+
+      def cells_coords_around(row_index, col_index)
+        coords_around = OFFSETS.map { |coords| [row_index + coords[0], col_index + coords[1]] }
+        coords_around.select { |coords| cell_exists_at?(coords[0], coords[1]) }
+      end
+
+      def cell_exists_at?(row_index, col_index)
+        (0...@row_count).include?(row_index) && (0...@row_count).include?(col_index)
+      end
+
+      def register_mine_at(row_index, col_index)
+        @all_mine_coords << [row_index, col_index]
+      end
+
+      def increase_mine_counters_around(row_index, col_index)
+        cells_around(row_index, col_index).each { |cell| cell.mines_around += 1 }
+      end
+
+      def cells_around(row_index, col_index)
+        cells_coords_around(row_index, col_index).map { |coords| cell_at(coords[0], coords[1])}
+      end
+
+      def cell_at(row_index, col_index)
+        @cells[row_index][col_index]
+      end
+
+      def reveal_at(row_index, col_index)
+        verify_coordinates_existance(row_index, col_index)
+        return if cell_at(row_index, col_index).revealed?
+        cell_at(row_index, col_index).reveal
+        if cell_at(row_index, col_index).mines_around.zero?
+          cells_coords_around(row_index, col_index).each do |coords|
+            reveal_at(coords[0], coords[1]) unless cell_at(coords[0], coords[1]).revealed?
+          end
+        end
+      end
+
+      def flag_at(row_index, col_index)
+        verify_coordinates_existance(row_index, col_index)
+        cell_at(row_index, col_index).flag
+        raise MinefieldSolvedError if !@all_mine_coords.empty? && all_mines_flagged?
+      end
+
+      def all_mines_flagged?
+        mined_cells = @all_mine_coords.map { |coords| cell_at(*coords) }
+        mined_cells.all?(&:flagged?)
+      end
+
+      def unflag_at(row_index, col_index)
+        verify_coordinates_existance(row_index, col_index)
+        cell_at(row_index, col_index).unflag
+      end
+
+      def mines_around(row_index, col_index)
+        cell_at(row_index, col_index).mines_around
+      end
+
+      private :create_non_explosive_cell
+      private :create_explosive_cell_at
+      private :cell_exists_at?
+      private :increase_mine_counters_around
+      private :mines_adjacent_to
+      private :cells_coords_around
+      private :register_mine_at
+      private :cells_around
+      private :cell_at
+      private :all_mines_flagged?
+    end
+  end
+end
+