minesweeprb 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8570b88e453c2b2831d7b4d155ece9b35191aa989b38c3df409cde3258af522
-  data.tar.gz: b4d5c63637d268285cc2a0a08d9b3011b9ceed0aaeabfb36fb63004b90938f82
+  metadata.gz: 1a4af15df91c5d1f7b09134c5effe760ae2c16ab6cf1b568599cacd7ae0c648b
+  data.tar.gz: e8b3bc60828dfd5f93e526a0ec8bdcecba7c4b7adf811fab6efb9a1e66b8ad97
 SHA512:
-  metadata.gz: 0250dbc2b118b525aad974cf1ab17001cff0484abdf4b2c49961d02e7f040a5f9dfdcb687473e3514f030899369ef650d61011cd68b9bf17c0ca0c36afa9ef7b
-  data.tar.gz: ecdb3eacfb7288c3f8383ac6936d782947c7c1fb06fcc57c80dba1e9b404508ff51526bebec7a793beee00e6d2e55e469354d3cae95cfebf5afce23c7727f990
+  metadata.gz: 950340b2ad509214d3a29b9ce6bfb150afd0e5c5bd51bed672d6ad995a9960b447be27ab45d20bc45b41d0496bd53b2171ed527164d92b4e4d51ec9631e15b9c
+  data.tar.gz: 0f4eda9e575449989c208b4d32430591f697b63728b5c4a7697c48f5f8b46a0f32cc0d79348f8f7ab61d9293984f4382f6155f194f21c1bcb4899265ba621de2

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+### 2020-02-08 0.4.0
+
+* Add custom boards
+* Fix gemspec
+
 ### 2020-02-08 0.3.0
 
 * Add mouse support

data/Gemfile.lock

@@ -1,13 +1,15 @@
 PATH
   remote: .
   specs:
-    minesweeprb (0.1.0)
+    minesweeprb (0.3.0)
+      curses (~> 1.3)
       timers (~> 4.3)
       tty (~> 0.10)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    curses (1.3.2)
     diff-lcs (1.3)
     equatable (0.6.1)
     kramdown (1.16.2)

data/README.md

@@ -10,7 +10,7 @@ Use clues on the gameboard to deduce locations of mines. Correctly reveal all no
 ## Install
 
 ```
-gem install minesweerb
+gem install minesweeprb
 ```
 
 ## Run
@@ -22,13 +22,13 @@ minesweeprb
 ## Rules
 A gameboard is composed of a number of squares laid out in a rectangle. 
 
-A square hold either a Clue or a Mine
+A square holds either a Clue or a Mine
 
 ### Clue Square
 A Clue Square will contain a number representing the numbers of mines that border itself. If the Clue Square has no neighboring mines then it will be blank.
 
 For example, a Clue Square containing a "1" will have exactly one mine in one of the spaces that borders itself.
-There is a mine in exactly one of the ? squares.
+There is a mine in exactly one of the ◼ squares.
 ```
 ◼ ◼ ◼
 ◼ 1 ◼
@@ -45,7 +45,7 @@ There are no mines surrounding an empty square. Note: Revealing an empty square
 ```
 where '◻' is an empty Clue Square.
 
-In the example below, there is a mine in exactly 3 of the ? squares. Because the "3" Clue Square only has three unrevealed spaces bordering itself, it is correct to assume that there is mine in each space.
+In the example below, there is a mine in exactly 3 of the ⚑ squares. Because the "3" Clue Square only has three unrevealed spaces bordering itself, it is correct to assume that there is mine in each space.
 ```
 3 ◼ ◼   3 ⚑ ◼
 ◼ ◼ ◼ → ⚑ ⚑ ◼
@@ -53,14 +53,14 @@ In the example below, there is a mine in exactly 3 of the ? squares. Because the
 ```
 
 ### Mine Square
-Mine Squares should not be revealed. If you believe you have found the location of a Mine then you can mark that square to prevent accidentally revealing it.
+Mine Squares should not be revealed. If you believe you have found the location of a Mine then you can flag that square to prevent accidentally revealing it.
 
 ## Gameboard
 A gameboard contains a Width, Height, and Number of Mines.
 
 The first move is always safe which means a gameboard's Mines are not placed until the first square is revealed.
 
-Since the first is always safe, a gameboard is only valid if the number of mines is less than the total number of squares. A valid gameboard must have more than one square. (i.e., 0 < # of Mines < Width * Height)
+Since the first move is always safe, a gameboard is only valid if the number of mines is less than the total number of squares. A valid gameboard must have more than one square. (i.e., 0 < # of Mines < Width * Height)
 
 ## How To Play
 Reveal squares you believe do not contain a Mine.
@@ -80,10 +80,12 @@ Reveal all Clue Squares without revealing a Mine.
 
 
 ## TODO
-* Extract Gameboard
+* ~Extract Gameboard~
 * Simplify logic
-* Repaint only what's necessary
-* Implement timer
+* ~Repaint only what's necessary~
+  * Separate squares and timer into separate window?
+* ~Implement timer~
 * Add Leaderboard
-* Add custom games (set width, height, and number of mines)
+* ~Add custom games (set width, height, and number of mines)~
 * Add peek mode, undo, or lives to help users learn
+* restarting a game brings back to prompt instead of generating a new board of the same dimensions

data/lib/minesweeprb/commands/play.rb

@@ -1,22 +1,32 @@
 # frozen_string_literal: true
 
-require 'tty-reader'
 require 'tty-screen'
 
 require_relative '../command'
-require_relative '../gameboard'
+require_relative '../../minesweeprb'
 
 module Minesweeprb
   module Commands
     class Play < Minesweeprb::Command
+      SIZES = [
+        # [ label, width, height, # of mines ]
+        ['Tiny',    5,  5,  3],
+        ['Small',   9,  9, 10],
+        ['Medium', 13, 13, 15],
+        ['Large',  17, 17, 20],
+        ['Huge',   21, 21, 25],
+      ].map { |options| GameTemplate.new(*options) }.freeze
+
       def initialize(options)
         @options = options
       end
 
       def execute(input: $stdin, output: $stdout)
-        size = prompt_size(output)
-        gameboard = Gameboard.new(size)
+        template = prompt_size(output)
+        template = prompt_custom(output) if template == :custom
 
+        game = Game.new(**template.to_h)
+        gameboard = Gameboard.new(game)
         begin
           gameboard.draw
         ensure
@@ -27,21 +37,63 @@ module Minesweeprb
       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
+        options = SIZES.map do |option|
+          too_big = option.height > TTY::Screen.height || option.width * 2 - 1 > TTY::Screen.width
           disabled = '(screen too small)' if too_big
-          size.merge(
-            value: index,
-            disabled: disabled
-          )
+          {
+            disabled: disabled,
+            name: option.label,
+            value: option,
+          }
+        end
+
+        options << {
+          name: 'Custom',
+          value: :custom
+        }
+
+        prompt(interrupt: -> { exit 1 }).select('Size:', options, cycle: true)
+      end
+
+      def prompt_custom(output)
+        min_width = 1
+        max_width = TTY::Screen.width / 2 - 1
+        width = prompt.ask("Width (#{min_width}-#{max_width})") do |q|
+          q.required true
+          q.convert :int
+          q.validate do |val|
+            val =~ /\d+/ && (min_width..max_width).include?(val.to_i)
+          end
         end
 
-        size = prompt(interrupt: -> { exit 1 }).select('Size:', sizes, cycle: true)
+        min_height = width == 1 ? 2 : 1
+        max_height = TTY::Screen.height - 10 # leave room for interface
+        height = prompt.ask("Height (#{min_height}-#{max_height})") do |q|
+          q.required true
+          q.convert :int
+          q.validate do |val|
+            val =~ /\d+/ && (min_height..max_height).include?(val.to_i)
+          end
+        end
+
+        min_mines = 1
+        max_mines = width * height - 1
+        mines = prompt.ask("Mines (#{min_mines}-#{max_mines})") do |q|
+          q.required true
+          q.convert :int
+          q.validate do |val|
+            val =~ /\d+/ && (min_mines..max_mines).include?(val.to_i)
+          end
+        end
+
+        GameTemplate.new('Custom', width, height, mines)
+      end
+
+      def clear_output(output)
         output.print cursor.hide
         output.print cursor.up(1)
         output.print cursor.clear_screen_down
         output.puts
-        size
       end
     end
   end

data/lib/minesweeprb/game.rb

@@ -2,8 +2,6 @@
 
 module Minesweeprb
   class Game
-    DEFAULT_SIZE = 'Tiny'
-    DEFAULT_MINE_COUNT = 1
     SPRITES = {
       clock: '◷',
       clues: '◻➊➋➌➍➎➏➐➑'.chars.freeze,
@@ -17,73 +15,36 @@ module Minesweeprb
     }.freeze
     WIN = "#{SPRITES[:win_face]} YOU WON #{SPRITES[:win_face]}"
     LOSE = "#{SPRITES[:lose_face]} GAME OVER #{SPRITES[:lose_face]}"
-    SIZES = [
-      {
-        name: 'Tiny',
-        width: 5,
-        height: 5,
-        mines: 3,
-      },
-      {
-        name: 'Small',
-        width: 9,
-        height: 9,
-        mines: 10,
-      },
-      {
-        name: 'Medium',
-        width: 13,
-        height: 13,
-        mines: 15,
-      },
-      {
-        name: 'Large',
-        width: 17,
-        height: 17,
-        mines: 20,
-      },
-      {
-        name: 'Huge',
-        width: 21,
-        height: 21,
-        mines: 25,
-      },
-    ].freeze
 
     attr_accessor :active_square
     attr_reader :flagged_squares,
+      :height,
       :marked_squares,
-      :mined_squares,
+      :mines,
       :revealed_squares,
-      :size,
-      :squares,
-      :start_time
+      :start_time,
+      :width
 
-    def initialize(size)
-      @size = SIZES[size]
+    def initialize(label:, width:, height:, mines:)
+      @width = width
+      @height = height
+      @mines = mines
       restart
     end
 
     def restart
       @active_square = center
-      @flagged_squares = []
-      @marked_squares = []
-      @mined_squares = []
-      @revealed_squares = {}
+      @flagged_squares = Set[]
+      @marked_squares = Set[]
+      @mined_squares = Set[]
+      @revealed_squares = Set[]
+      @grid = Array.new(height) { Array.new(width) }
       @start_time = nil
       @end_time = nil
     end
 
-    def mines
-      size[:mines] - flagged_squares.size
-    end
-
-    def width
-      size[:width]
-    end
-
-    def height
-      size[:height]
+    def remaining_mines
+      mines - flagged_squares.length
     end
 
     def center
@@ -97,13 +58,13 @@ module Minesweeprb
     def time
       return 0 unless start_time
 
-      (end_time - start_time).round
+      end_time - start_time
     end
 
     def move(direction)
       return if over?
 
-      x, y = @active_square
+      x, y = active_square
 
       case direction
       when :up then y -= 1
@@ -112,6 +73,11 @@ module Minesweeprb
       when :right then x += 1
       end
 
+      self.active_square = [x,y]
+    end
+
+    def active_square=(pos)
+      x, y = pos
       x = x < 0 ? width - 1 : x
       x = x > width - 1 ? 0 : x
       y = y < 0 ? height - 1 : y
@@ -131,20 +97,20 @@ module Minesweeprb
     end
 
     def header
-      "#{SPRITES[:mine]} #{mines.to_s.rjust(3, '0')}" \
+      "#{SPRITES[:mine]} #{remaining_mines.to_s.rjust(3, '0')}" \
       "  #{face}  " \
-      "#{SPRITES[:clock]} #{time.to_s.rjust(3, '0')}"
+      "#{SPRITES[:clock]} #{time.round.to_s.rjust(3, '0')}"
     end
 
     def cycle_flag
-      return if over? || @revealed_squares.empty? || @revealed_squares.include?(active_square)
+      return if over? || revealed_squares.empty? || revealed_squares.include?(active_square)
 
       if flagged_squares.include?(active_square)
         @flagged_squares -= [active_square]
         @marked_squares += [active_square]
       elsif marked_squares.include?(active_square)
         @marked_squares -= [active_square]
-      elsif flagged_squares.length < size[:mines]
+      elsif flagged_squares.length < mines
         @flagged_squares += [active_square]
       end
     end
@@ -152,22 +118,23 @@ module Minesweeprb
     def reveal_active_square
       return if over? || flagged_squares.include?(active_square)
 
-      reveal_square(active_square)
+      x, y = active_square
+      reveal_square(x, y)
       @end_time = now if over?
     end
 
-    def squares
+    def play_grid
       height.times.map do |y|
         width.times.map do |x|
-          pos = [x,y]
+          square = [x,y]
 
-          if mined_squares.include?(pos) && (revealed_squares[pos] || over?)
+          if @mined_squares.include?(square) && (revealed_squares.include?(square) || over?)
             SPRITES[:mine]
-          elsif flagged_squares.include?(pos)
+          elsif revealed_squares.include?(square) || over?
+            SPRITES[:clues][@grid[y][x]]
+          elsif flagged_squares.include?(square)
             SPRITES[:flag]
-          elsif revealed_squares[pos]
-            SPRITES[:clues][revealed_squares[pos]]
-          elsif marked_squares.include?(pos)
+          elsif marked_squares.include?(square)
             SPRITES[:mark]
           else
             SPRITES[:square]
@@ -181,11 +148,11 @@ module Minesweeprb
     end
 
     def won?
-      !lost? && revealed_squares.count == width * height - size[:mines]
+      !lost? && revealed_squares.count == width * height - mines
     end
 
     def lost?
-      (revealed_squares.keys & mined_squares).any?
+      (revealed_squares & @mined_squares).any?
     end
 
     def over?
@@ -204,13 +171,14 @@ module Minesweeprb
 
     def start_game
       place_mines
+      place_clues
       @start_time = now
     end
 
     def place_mines
-      size[:mines].times do
+      mines.times do
         pos = random_square
-        pos = random_square while pos == active_square || mined_squares.include?(pos)
+        pos = random_square while pos == active_square || @mined_squares.include?(pos)
         @mined_squares << pos
       end
     end
@@ -221,43 +189,54 @@ module Minesweeprb
       [x, y]
     end
 
-    def reveal_square(square)
+    def place_clues
+      width.times do |x|
+        height.times do |y|
+          @grid[y][x] = square_value(x,y)
+        end
+      end
+    end
+
+    def square_value(x,y)
+      return if @mined_squares.include?([x,y])
+
+      (neighbors(x,y) & @mined_squares).length
+    end
+
+    def reveal_square(x,y)
+      square = [x,y]
       return if over? || flagged_squares.include?(active_square)
       start_game if revealed_squares.empty?
-      return if revealed_squares.keys.include?(square)
-      return lose! if mined_squares.include?(square)
+      return if revealed_squares.include?(square)
+      return lose! if @mined_squares.include?(square)
 
-      value = square_value(square)
-      @revealed_squares[square] = value
-      neighbors(square).each { |neighbor| reveal_square(neighbor) } if value.zero?
+      @revealed_squares << [x,y]
+      value = @grid[y][x]
+      neighbors(x,y).each { |x,y| reveal_square(x,y) } if value == 0
     end
 
     def lose!
-      @mined_squares.each { |square| @revealed_squares[square] = -1 }
-    end
-
-    def square_value(square)
-      (neighbors(square) & mined_squares).size
+      @revealed_squares |= @mined_squares
     end
 
-    def neighbors(square)
+    def neighbors(x,y)
       [
         # top
-        [square[0] - 1, square[1] - 1],
-        [square[0] - 0, square[1] - 1],
-        [square[0] + 1, square[1] - 1],
+        [x - 1, y - 1],
+        [x - 0, y - 1],
+        [x + 1, y - 1],
 
-        # middle
-        [square[0] - 1, square[1] - 0],
-        [square[0] + 1, square[1] - 0],
+        # sides
+        [x - 1, y - 0],
+        [x + 1, y - 0],
 
         # bottom
-        [square[0] - 1, square[1] + 1],
-        [square[0] - 0, square[1] + 1],
-        [square[0] + 1, square[1] + 1],
+        [x - 1, y + 1],
+        [x - 0, y + 1],
+        [x + 1, y + 1],
       ].select do |x,y|
-        (0...width).include?(x) && (0...height).include?(y)
-      end
+        x.between?(0, width-1) && y.between?(0, height-1)
+      end.to_set
     end
   end
 end

data/lib/minesweeprb/game_template.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Minesweeprb
+  class GameTemplate < Struct.new(:label, :width, :height, :mines)
+  end
+end

data/lib/minesweeprb/gameboard.rb

@@ -2,7 +2,6 @@
 
 require 'curses'
 require 'timers'
-require_relative './game'
 
 module Minesweeprb
   class Gameboard
@@ -48,20 +47,39 @@ module Minesweeprb
 
     COLOR_PAIRS = COLORS.keys.freeze
 
-    attr_reader :game, :pastel, :window, :game_x, :game_y
+    attr_reader :game, :windows, :game_x, :game_y
 
-    def initialize(size)
-      @pastel = Pastel.new
-      @game = Game.new(size)
-      @timers = Timers::Group.new
-      @game_timer = @timers.every(0.5) { paint }
+    def initialize(game)
+      @game = game
       setup_curses
-      Thread.new { loop { @timers.wait } }
+    end
+
+    def w_header
+      windows[:header]
+    end
+
+    def w_grid
+      windows[:grid]
+    end
+
+    def w_status
+      windows[:status]
+    end
+
+    def w_instructions
+      windows[:instructions]
+    end
+
+    def w_debug
+      windows[:debug]
     end
 
     def draw
-      paint
-      draw if process_input(window.getch)
+      # paint_debug
+      Thread.new { loop { paint_header && sleep(0.5) } }
+
+      paint_grid
+      paint_grid while process_input(w_grid.getch)
     end
 
     def clear
@@ -71,21 +89,63 @@ module Minesweeprb
     private 
 
     def setup_curses
-      init_screen
+      screen = init_screen
       use_default_colors
       start_color
       curs_set(0)
       noecho
       self.ESCDELAY = 1;
       mousemask(BUTTON1_CLICKED|BUTTON2_CLICKED|BUTTON3_CLICKED|BUTTON4_CLICKED)
-      @window = Window.new(0, 0, 0, 0)
-      @window.keypad(true)
+
+      header = {
+        top: 1,
+        left: (screen.maxx - game.header.length) / 2,
+        cols: game.header.length,
+        rows: 1,
+      }
+      grid = {
+        left: (screen.maxx - (game.width * 2 - 1)) / 2,
+        top: header[:top] + header[:rows] + 1,
+        cols: game.width * 2 - 1, # leave room for spaces between squares
+        rows: game.height,  # leave room for win/lose status and instructions
+      }
+      status = {
+        left: 0,
+        top: grid[:top] + grid[:rows] + 1,
+        cols: 0,
+        rows: 1,
+      }
+      instructions = {
+        left: 0,
+        top: status[:top] + status[:rows] + 1,
+        cols: 0,
+        rows: 1,
+      }
+      debug = {
+        left: 0,
+        top: screen.maxy - 1,
+        cols: 0,
+        rows: 1,
+      }
+
+      @windows = {}
+      @windows[:header] = build_window(**header)
+      @windows[:grid] = build_window(**grid)
+      @windows[:status] = build_window(**status)
+      @windows[:instructions] = build_window(**instructions)
+      @windows[:debug] = build_window(**debug)
+      @windows[:grid].keypad(true)
+
       COLOR_PAIRS.each.with_index do |char, index|
         fg, bg = COLORS[char]
         init_pair(index + 1, fg, bg || -1)
       end
     end
 
+    def build_window(rows:, cols:, top:, left:)
+      Window.new(rows, cols, top, left)
+    end
+
     def process_input(key)
       case key
       when KEY_MOUSE then process_mouse(getmouse)
@@ -100,17 +160,17 @@ module Minesweeprb
     end
 
     def process_mouse(m)
-      top = game_y
-      left = game_x
-      bottom = game_y + game.height
-      right = game_x + game.width * 2 - 1
+      top = w_grid.begy
+      left = w_grid.begx
+      bottom = top + game.height
+      right = left + game.width * 2 - 1
       on_board = (top..bottom).include?(m.y) &&
         (left..right).include?(m.x) &&
-        (m.x - game_x).even?
+        (m.x - w_grid.begx).even?
 
       return if !on_board && !game.over?
 
-      game.active_square = [(m.x - game_x) / 2, m.y - game_y]
+      game.active_square = [(m.x - w_grid.begx) / 2, m.y - w_grid.begy]
 
       case m.bstate
         when BUTTON1_CLICKED then game.reveal_active_square
@@ -118,70 +178,75 @@ module Minesweeprb
       end
     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('  ')
+    def paint_header
+      w_header.setpos(0,0)
+
+      game.header.chars.each do |char|
+        w_header.attron(color_for(char)) { w_header << char }
+      end
+
+      w_header.refresh
     end
 
-    def paint
-      window.clear
-      window << "\n"
-      game.header.center(window.maxx - 1).chars.each do |char|
-        window.attron(color_for(char)) { window << char }
+    def paint_debug
+      COLORS.keys.each do |char|
+        w_debug.attron(color_for(char)) { w_debug << char.to_s }
       end
-      clrtoeol
-      window << "\n"
-
-      # COLOR_PAIRS.each do |char|
-      #   window.attron(color_for(char)) { window << char }
-      # end
-      # clrtoeol
-      # window << "\n"
-
-      padding = (window.maxx - game.width * 2) / 2
-      game.squares.each.with_index do |line, row|
-        window << ' ' * padding
-        @game_x, @game_y = window.curx, window.cury if row.zero?
+      w_debug.refresh
+    end
+
+    def paint_grid
+      w_grid.setpos(0,0)
+
+      game.play_grid.each.with_index do |line, row|
         line.each.with_index do |char, col|
+          w_grid.setpos(row, col * 2) if col < line.length
+
           if game.active_square == [col, row]
-            window.attron(color_for(char) | A_REVERSE) { window << char }
+            w_grid.attron(color_for(char) | A_REVERSE) { w_grid << char }
           else
-            window.attron(color_for(char)) { window << char }
+            w_grid.attron(color_for(char)) { w_grid << char }
           end
-          window << ' ' if col < line.length
         end
-        clrtoeol
-        window << "\n"
       end
 
+      paint_status
+      paint_instructions
+
+      w_grid.refresh
+      w_status.refresh
+      w_instructions.refresh
+    end
+
+    def paint_status
       if game.over?
-        window << "\n"
+        w_status.setpos(0,0)
         outcome = game.won? ? :win : :lose
-        message = game.game_over_message.center(window.maxx - 1)
+        message = game.game_over_message.center(w_status.maxx - 1)
         message.chars.each do |char|
           char_color = color_for(char)
 
           if char_color.zero?
-            window.attron(color_for(outcome)) { window << char }
+            w_status.attron(color_for(outcome)) { w_status << char }
           else
-            window.attron(char_color) { window << char }
+            w_status.attron(char_color) { w_status << char }
           end
         end
-        clrtoeol
-        window << "\n"
+      else
+        w_status.clear
       end
+    end
 
-      window << "\n"
-      window << how_to_play.center(window.maxx - 1)
-      clrtoeol
-      window << "\n"
+    def paint_instructions
+      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'
 
-      window.refresh
+      w_instructions.setpos(0,0)
+      w_instructions << instructions.join(' ').center(w_instructions.maxx - 1)
     end
 
     def color_for(char)

data/lib/minesweeprb/version.rb

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

data/lib/minesweeprb.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require 'minesweeprb/version'
+require 'minesweeprb/game'
+require 'minesweeprb/game_template'
+require 'minesweeprb/gameboard'
 
 module Minesweeprb
   class Error < StandardError; end

data/minesweeprb.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.add_runtime_dependency 'curses', '~> 1.3'
   spec.add_runtime_dependency 'timers', '~> 4.3'
   spec.add_runtime_dependency 'tty', '~> 0.10'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minesweeprb
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - scudco
@@ -10,6 +10,20 @@ bindir: exe
 cert_chain: []
 date: 2020-02-09 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: curses
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: timers
   requirement: !ruby/object:Gem::Requirement
@@ -65,6 +79,7 @@ files:
 - lib/minesweeprb/commands/.gitkeep
 - lib/minesweeprb/commands/play.rb
 - lib/minesweeprb/game.rb
+- lib/minesweeprb/game_template.rb
 - lib/minesweeprb/gameboard.rb
 - lib/minesweeprb/templates/.gitkeep
 - lib/minesweeprb/templates/play/.gitkeep