minesweeprb 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0a927b6f66d1e8859c03abc54b13a0cbbc493d6f49363ff64749e7492dca708
-  data.tar.gz: 19bcd6ea2b5eba19d15a130e801198380b7d75362bd7a30e4978ae9073eb92f7
+  metadata.gz: 16bc74524f23df3a1ab558f120560e152b2a1c7551379a6237eefac7cf48962b
+  data.tar.gz: f879f2d59af8c486aa34114fcc77995a7a1951edeac59026d9c54ecbdeda09af
 SHA512:
-  metadata.gz: 5dd06487cef1c41d3ace0c74f2faa9d1b221f677f61605dff72b1c4f2bfd298c28a09d26eec4f3bc7a516584c7cb77d863902c1b75813c9ddf80ae232f2e4e7c
-  data.tar.gz: 4bba0e734f6140c4ef5e147e713d38ce874ede0b9a3b2c5b2bb3462a7cddc41555ea4aaf3c93ccaf758729293868341ace2ce12f3f0e685abed30118d8bcf5ff
+  metadata.gz: 73cfcc1a3d6e6099f122eb340b567d7517d1853b7654d93ef00df9da1c08ba5ace35a36dbf54d8ec49651c9e5a97f3d09d7cec0255d9f910892aad26589400ec
+  data.tar.gz: aae8f678ed0182f6d76cee2df5491c007a57b91ba1f45625e593a5ffc02d2b1e0d4eb96ea859f5d2b1107d78c1bbbbfe6f2cd4afffecd87a7f8e30cf539fb2ec

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+### 2020-02-08 0.2.0
+
+* Use curses for gameboard to reduce flickering

data/Gemfile.lock

@@ -2,6 +2,7 @@ PATH
   remote: .
   specs:
     minesweeprb (0.1.0)
+      timers (~> 4.3)
       tty (~> 0.10)
 
 GEM
@@ -35,6 +36,7 @@ GEM
       unicode_utils (~> 1.4)
     strings-ansi (0.1.0)
     thor (0.20.3)
+    timers (4.3.0)
     tty (0.10.0)
       bundler (~> 1.16, < 2.0)
       equatable (~> 0.5)

data/README.md

@@ -2,6 +2,23 @@
 
 Use clues on the gameboard to deduce locations of mines. Correctly reveal all non-mine squares to win.
 
+<p align="center">
+  <img src="screenshots/play.png" width="940" />
+  <img src="screenshots/win.png" width="394" />
+</p>
+
+## Install
+
+```
+gem install minesweerb
+```
+
+## Run
+
+```
+minesweeprb
+```
+
 ## Rules
 A gameboard is composed of a number of squares laid out in a rectangle. 
 
@@ -56,7 +73,17 @@ If you reveal a square that contains a Mine, the game will end.
 Reveal all Clue Squares without revealing a Mine.
 
 ### ASCII Reference
-* Flags `⚑`
-* Squares `◻ ◼ ▣`
-* Numbers `➊ ➋ ➌ ➍ ➎ ➏ ➀ ➁ ➂ ➃ ➄ ➅`
-* Mines `☀ ☼ ✺`
+* Flags `⚑ ⍰`
+* Square `◼`
+* Clues `◻ ➊ ➋ ➌ ➍ ➎ ➏ ➐ ➑`
+* Mine `☀`
+
+
+## TODO
+* Extract Gameboard
+* Simplify logic
+* Repaint only what's necessary
+* Implement timer
+* Add Leaderboard
+* Add custom games (set width, height, and number of mines)
+* Add peek mode, undo, or lives to help users learn

data/lib/minesweeprb/commands/play.rb

@@ -1,32 +1,32 @@
 # frozen_string_literal: true
 
-require 'pastel'
 require 'tty-reader'
 require 'tty-screen'
 
 require_relative '../command'
-require_relative '../game'
+require_relative '../gameboard'
 
 module Minesweeprb
   module Commands
     class Play < Minesweeprb::Command
-      VIM_MAPPING = {
-        'k' => :up,
-        'j' => :down,
-        'h' => :left,
-        'l' => :right,
-      }.freeze
-
-      attr_reader :game, :pastel
-
       def initialize(options)
         @options = options
-        @pastel = Pastel.new
       end
 
-      def start_game(output)
-        height, width = 
+      def execute(input: $stdin, output: $stdout)
+        size = prompt_size(output)
+        gameboard = Gameboard.new(size)
+
+        begin
+          gameboard.draw
+        ensure
+          gameboard.clear
+        end
+      end
+
+      private
 
+      def prompt_size(output)
         sizes = Game::SIZES.map.with_index do |size, index|
           too_big = size[:height] * 2 > TTY::Screen.height || size[:width] * 2 > TTY::Screen.width
           disabled = '(screen too small)' if too_big
@@ -41,144 +41,7 @@ module Minesweeprb
         output.print cursor.up(1)
         output.print cursor.clear_screen_down
         output.puts
-
-        @game = Minesweeprb::Game.new(size)
-
-        print_gameboard(output)
-      end
-
-      def how_to_play
-        instructions = []
-        instructions << '(←↓↑→ or hjkl) Move' unless game.over?
-        instructions << '(f or ␣)Flag/Mark' if game.started?
-        instructions << '(↵)Reveal' unless game.over?
-        instructions << '(r)Restart'
-        instructions << '(q)Quit'
-        instructions.join('  ')
-      end
-
-      def execute(input: $stdin, output: $stdout)
-        start_game(output)
-
-        reader
-          .on(:keyescape) { exit }
-          .on(:keyalpha) do |event|
-            key = event.value.downcase
-            case key
-            when 'q' then exit
-            when 'r'
-              output.print cursor.clear_screen_down
-              start_game(output)
-            when 'f'
-              unless game.over?
-                game.cycle_flag
-                print_gameboard(output)
-              end
-            when 'j', 'k', 'h', 'l'
-              unless game.over?
-                game.move(VIM_MAPPING[key])
-                print_gameboard(output)
-              end
-            end
-
-          end.on(:keypress) do |event|
-            unless game.over?
-              case event.key.name
-              when :up, :down, :left, :right
-                game.move(event.key.name)
-              when :space
-                game.cycle_flag
-              when :return
-                game.reveal_active_square
-              end
-
-              print_gameboard(output)
-            end
-          end
-
-        loop { reader.read_keypress }
-      end
-
-      def reader
-        @reader ||= TTY::Reader.new
-      end
-
-      def print_gameboard(output)
-        total_height = game.height + game.header.lines.length + 1
-        output.print cursor.clear_lines(total_height, :down)
-        output.print cursor.up(total_height - 2)
-
-        game.header.each_line do |line|
-          chars = line.chars.map do |char|
-            case char
-            when Game::WON_FACE then pastel.bright_yellow(char)
-            when Game::LOST_FACE then pastel.bright_red(char)
-            when Game::PLAYING_FACE then pastel.bright_cyan(char)
-            when Game::MINE then pastel.bright_red(char)
-            when Game::CLOCK then pastel.bright_cyan(char)
-            else
-              char
-            end
-          end
-
-          center(output, chars.join)
-        end
-
-        game.squares.each.with_index do |row, y|
-          line = row.map.with_index do |char, x|
-            char = case char
-                   when Game::FLAG then pastel.bright_red(char)
-                   when Game::MINE
-                     if game.won?
-                       pastel.bright_green(char)
-                     elsif game.active_square == [x,y]
-                       pastel.black.on_bright_red(char)
-                     else
-                       pastel.bright_red(char)
-                     end
-                   when Game::MARK then pastel.bright_magenta(char)
-                   when Game::CLUES[0] then pastel.dim(char)
-                   when Game::CLUES[1] then pastel.blue(char)
-                   when Game::CLUES[2] then pastel.green(char)
-                   when Game::CLUES[3] then pastel.red(char)
-                   when Game::CLUES[4] then pastel.magenta(char)
-                   when Game::CLUES[5] then pastel.black(char)
-                   when Game::CLUES[6] then pastel.bright_red(char)
-                   when Game::CLUES[7] then pastel.bright_white(char)
-                   when Game::CLUES[8] then pastel.bright_cyan(char)
-                   else
-                     char
-                   end
-
-            !game.over? && game.active_square == [x,y] ? pastel.inverse(char): char
-          end.join(' ')
-
-          center(output, line)
-        end
-
-
-        output.print cursor.clear_screen_down
-        output.puts
-
-        if game.won?
-          center(output, pastel.bright_green.bold('☻ YOU WON ☻'))
-          output.puts
-          center(output, how_to_play)
-        elsif game.lost?
-          center(output, pastel.bright_magenta.bold('☹ GAME OVER ☹'))
-          output.puts
-          center(output, how_to_play)
-        else
-          center(output, how_to_play)
-          output.print cursor.up(total_height + 2)
-        end
-      end
-
-      def center(output, line)
-        width = TTY::Screen.width
-        padding = (width - (pastel.strip(line.chomp.strip).length)) / 2
-        output.print(' ' * [padding, 0].max)
-        output.puts line
+        size
       end
     end
   end

data/lib/minesweeprb/game.rb

@@ -1,21 +1,22 @@
 # frozen_string_literal: true
 
-require 'pastel'
-
 module Minesweeprb
   class Game
     DEFAULT_SIZE = 'Tiny'
     DEFAULT_MINE_COUNT = 1
-    FLAG = '⚑'
-    SQUARE = '◼'
-    ACTIVE_SQUARE = '▣'
-    MARK = '⍰'
-    CLUES = '◻➊➋➌➍➎➏➐➑'.chars.freeze
-    CLOCK = '◷'
-    MINE = '☀'
-    WON_FACE = '☻'
-    LOST_FACE = '☹'
-    PLAYING_FACE = '☺'
+    SPRITES = {
+      clock: '◷',
+      clues: '◻➊➋➌➍➎➏➐➑'.chars.freeze,
+      flag: '✖', # ⚑ Flag does not work in curses?
+      lose_face: '☹',
+      mark: '⍰',
+      mine: '☀',
+      play_face: '☺',
+      square: '◼',
+      win_face: '☻',
+    }.freeze
+    WIN = "#{SPRITES[:win_face]} YOU WON #{SPRITES[:win_face]}"
+    LOSE = "#{SPRITES[:lose_face]} GAME OVER #{SPRITES[:lose_face]}"
     SIZES = [
       {
         name: 'Tiny',
@@ -53,19 +54,24 @@ module Minesweeprb
       :flagged_squares,
       :marked_squares,
       :mined_squares,
-      :pastel,
       :revealed_squares,
       :size,
-      :squares
+      :squares,
+      :start_time
 
     def initialize(size)
-      @pastel = Pastel.new
       @size = SIZES[size]
+      restart
+    end
+
+    def restart
       @active_square = center
       @flagged_squares = []
       @marked_squares = []
       @mined_squares = []
       @revealed_squares = {}
+      @start_time = nil
+      @end_time = nil
     end
 
     def mines
@@ -84,8 +90,14 @@ module Minesweeprb
       [(width / 2).floor, (height / 2).floor]
     end
 
+    def end_time
+      @end_time || now
+    end
+
     def time
-      0
+      return 0 unless start_time
+
+      (end_time - start_time).round
     end
 
     def move(direction)
@@ -110,18 +122,18 @@ module Minesweeprb
 
     def face
       if won?
-        WON_FACE
+        SPRITES[:win_face]
       elsif lost?
-        LOST_FACE
+        SPRITES[:lose_face]
       else
-        PLAYING_FACE
+        SPRITES[:play_face]
       end
     end
 
     def header
-      "#{MINE} #{mines.to_s.rjust(3, '0')}" \
+      "#{SPRITES[:mine]} #{mines.to_s.rjust(3, '0')}" \
       "  #{face}  " \
-      "#{CLOCK} #{time.to_s.rjust(3, '0')}"
+      "#{SPRITES[:clock]} #{time.to_s.rjust(3, '0')}"
     end
 
     def cycle_flag
@@ -141,6 +153,7 @@ module Minesweeprb
       return if over? || flagged_squares.include?(active_square)
 
       reveal_square(active_square)
+      @end_time = now if over?
     end
 
     def squares
@@ -149,15 +162,15 @@ module Minesweeprb
           pos = [x,y]
 
           if mined_squares.include?(pos) && (revealed_squares[pos] || over?)
-            MINE
+            SPRITES[:mine]
           elsif flagged_squares.include?(pos)
-            FLAG
+            SPRITES[:flag]
           elsif marked_squares.include?(pos)
-            MARK
+            SPRITES[:mark]
           elsif revealed_squares[pos]
-            CLUES[revealed_squares[pos]]
+            SPRITES[:clues][revealed_squares[pos]]
           else
-            SQUARE
+            SPRITES[:square]
           end
         end
       end
@@ -179,8 +192,21 @@ module Minesweeprb
       won? || lost?
     end
 
+    def game_over_message
+      won? ? WIN : LOSE
+    end
+
     private
 
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def start_game
+      place_mines
+      @start_time = now
+    end
+
     def place_mines
       size[:mines].times do
         pos = random_square
@@ -196,7 +222,7 @@ module Minesweeprb
     end
 
     def reveal_square(square)
-      place_mines if revealed_squares.empty?
+      start_game if revealed_squares.empty?
       return if revealed_squares.keys.include?(square)
       return lose! if mined_squares.include?(square)
 

data/lib/minesweeprb/gameboard.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require 'curses'
+require 'timers'
+require_relative './game'
+
+module Minesweeprb
+  class Gameboard
+    RESTART = ['r'].freeze
+    REVEAL = [10, Curses::KEY_ENTER].freeze
+    FLAG = ['f', ' '].freeze
+    QUIT = ['q', 27].freeze
+
+    MOVE = {
+      Curses::KEY_UP => :up,
+      Curses::KEY_DOWN => :down,
+      Curses::KEY_LEFT => :left,
+      Curses::KEY_RIGHT => :right,
+      'k' => :up,
+      'j' => :down,
+      'h' => :left,
+      'l' => :right,
+    }.freeze
+
+    COLORS = {
+      win: [Curses::A_BOLD | Curses::COLOR_GREEN],
+      lose: [Curses::A_BOLD | Curses::COLOR_MAGENTA],
+      Game::SPRITES[:clock] => [Curses::A_BOLD | Curses::COLOR_CYAN],
+      Game::SPRITES[:win_face] => [Curses::A_BOLD | Curses::COLOR_YELLOW],
+      Game::SPRITES[:lose_face] => [Curses::A_BOLD | Curses::COLOR_RED],
+      Game::SPRITES[:play_face] => [Curses::A_BOLD | Curses::COLOR_CYAN],
+
+      Game::SPRITES[:mine] => [Curses::A_BOLD | Curses::COLOR_RED],
+      Game::SPRITES[:flag] => [Curses::A_BOLD | Curses::COLOR_RED],
+      Game::SPRITES[:mark] => [Curses::A_BOLD | Curses::COLOR_MAGENTA],
+      Game::SPRITES[:clues][0] => [Curses::COLOR_BLACK],
+      Game::SPRITES[:clues][1] => [Curses::COLOR_BLUE],
+      Game::SPRITES[:clues][2] => [Curses::COLOR_GREEN],
+      Game::SPRITES[:clues][3] => [Curses::COLOR_MAGENTA],
+      Game::SPRITES[:clues][4] => [Curses::COLOR_CYAN],
+      Game::SPRITES[:clues][5] => [Curses::COLOR_RED],
+      Game::SPRITES[:clues][6] => [Curses::COLOR_YELLOW],
+      Game::SPRITES[:clues][7] => [Curses::A_BOLD | Curses::COLOR_MAGENTA],
+      Game::SPRITES[:clues][8] => [Curses::A_BOLD | Curses::COLOR_RED],
+    }.freeze
+
+    COLOR_PAIRS = COLORS.keys.freeze
+
+    attr_reader :game, :pastel, :window
+
+    def initialize(size)
+      @pastel = Pastel.new
+      @game = Game.new(size)
+      @timers = Timers::Group.new
+      @game_timer = @timers.every(0.5) { paint }
+      Thread.new { loop { @timers.wait } }
+      setup_curses
+    end
+
+    def draw
+      paint
+      draw if process_input(window.getch)
+    end
+
+    def clear
+      Curses.close_screen
+    end
+
+    private 
+
+    def setup_curses
+      Curses.init_screen
+      Curses.use_default_colors
+      Curses.start_color
+      Curses.curs_set(0)
+      Curses.noecho
+      Curses.ESCDELAY = 1;
+      @window = Curses::Window.new(0, 0, 0, 0)
+      @window.keypad(true)
+      COLOR_PAIRS.each.with_index do |char, index|
+        fg, bg = COLORS[char]
+        Curses.init_pair(index + 1, fg, bg || -1)
+      end
+    end
+
+    def process_input(key)
+      case key
+      when *MOVE.keys then game.move(MOVE[key])
+      when *REVEAL then game.reveal_active_square
+      when *FLAG then game.cycle_flag
+      when *RESTART then game.restart
+      when *QUIT then return false
+      end
+
+      true
+    end
+
+    def how_to_play
+      instructions = []
+      instructions << '(←↓↑→ or hjkl)Move' unless game.over?
+      instructions << '(f or ␣)Flag/Mark' if game.started?
+      instructions << '(↵)Reveal' unless game.over?
+      instructions << '(r)Restart'
+      instructions << '(q or ⎋)Quit'
+      instructions.join('  ')
+    end
+
+    def paint
+      window.clear
+      window << "\n"
+      game.header.center(window.maxx - 1).chars.each do |char|
+        window.attron(color_for(char)) { window << char }
+      end
+      Curses.clrtoeol
+      window << "\n"
+
+      # COLOR_PAIRS.each do |char|
+      #   window.attron(color_for(char)) { window << char }
+      # end
+      # Curses.clrtoeol
+      # window << "\n"
+
+      padding = (window.maxx - game.width * 2) / 2
+      game.squares.each.with_index do |line, row|
+        window << ' ' * padding
+        line.each.with_index do |char, col|
+          if game.active_square == [col, row]
+            window.attron(color_for(char) | Curses::A_REVERSE) { window << char }
+          else
+            window.attron(color_for(char)) { window << char }
+          end
+          window << ' ' if col < line.length
+        end
+        Curses.clrtoeol
+        window << "\n"
+      end
+
+      if game.over?
+        window << "\n"
+        outcome = game.won? ? :win : :lose
+        message = game.game_over_message.center(window.maxx - 1)
+        message.chars.each do |char|
+          char_color = color_for(char)
+
+          if char_color.zero?
+            window.attron(color_for(outcome)) { window << char }
+          else
+            window.attron(char_color) { window << char }
+          end
+        end
+        Curses.clrtoeol
+        window << "\n"
+      end
+
+      window << "\n"
+      window << how_to_play.center(window.maxx - 1)
+      Curses.clrtoeol
+      window << "\n"
+
+      window.refresh
+    end
+
+    def color_for(char)
+      pair = COLOR_PAIRS.index(char)
+
+      if pair
+        Curses.color_pair(pair + 1)
+      else
+        0
+      end
+    end
+  end
+end

data/lib/minesweeprb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Minesweeprb
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/minesweeprb.gemspec

@@ -22,12 +22,13 @@ Gem::Specification.new do |spec|
   # into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject do |f|
-      f.match(%r{^(test|spec|features)/})
+      f.match(%r{^(test|spec|features|screenshots)/})
     end
   end
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.add_runtime_dependency 'timers', '~> 4.3'
   spec.add_runtime_dependency 'tty', '~> 0.10'
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: minesweeprb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - scudco
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-06 00:00:00.000000000 Z
+date: 2020-02-08 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: timers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
 - !ruby/object:Gem::Dependency
   name: tty
   requirement: !ruby/object:Gem::Requirement
@@ -36,6 +50,7 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -50,6 +65,7 @@ files:
 - lib/minesweeprb/commands/.gitkeep
 - lib/minesweeprb/commands/play.rb
 - lib/minesweeprb/game.rb
+- lib/minesweeprb/gameboard.rb
 - lib/minesweeprb/templates/.gitkeep
 - lib/minesweeprb/templates/play/.gitkeep
 - lib/minesweeprb/version.rb