minehunter 0.1.0

data/exe/minehunt

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+load File.expand_path("minehunter", __dir__)

data/exe/minehunter

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/minehunter"
+
+Minehunter.run

data/lib/minehunter/cli.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "tty-option"
+require "tty-screen"
+
+require_relative "game"
+require_relative "version"
+
+module Minehunter
+  # The main interface to the game
+  #
+  # @api public
+  class CLI
+    include TTY::Option
+
+    LEVELS = {
+      "easy" => {width: 9, height: 9, mines: 10},
+      "medium" => {width: 16, height: 16, mines: 40},
+      "hard" => {width: 30, height: 16, mines: 99}
+    }.freeze
+
+    usage do
+      no_command
+
+      desc "Hunt down all the mines and uncover remaining fields"
+
+      example "To play the game on a 20x15 grid with 35 mines run"
+
+      example "$ #{program} -c 20 -r 15 -m 35"
+    end
+
+    option :width do
+      short "-c"
+      long "--cols INT"
+      desc "Set number of columns"
+      convert :int
+    end
+
+    option :height do
+      short "-r"
+      long "--rows INT"
+      desc "Set number of rows"
+      convert :int
+    end
+
+    option :level do
+      default "medium"
+      short "-l"
+      long "--level NAME"
+      desc "Set difficulty level"
+      permit %w[easy medium hard]
+    end
+
+    option :mines do
+      short "-m"
+      long "--mines INT"
+      desc "Set number of mines"
+      convert :int
+    end
+
+    flag :help do
+      short "-h"
+      long "--help"
+      desc "Print usage"
+    end
+
+    flag :version do
+      short "-v"
+      long "--version"
+      desc "Print version"
+    end
+
+    # Run the game
+    #
+    # @param [Array<String>] argv
+    #   the command line parameters
+    # @param [IO] input
+    #   the input stream, defaults to stdin
+    # @param [IO] output
+    #   the output stream, defaults to stdout
+    # @param [Hash] env
+    #   the environment variables
+    # @param [Boolean] color
+    #   whether or not to style the game
+    # @param [Integer] screen_width
+    #   the terminal screen width
+    # @param [Integer] screen_height
+    #   the terminal screen height
+    #
+    # @api public
+    def run(argv = ARGV, input: $stdin, output: $stdout, env: {}, color: nil,
+            screen_width: TTY::Screen.width, screen_height: TTY::Screen.height)
+      parse(argv)
+
+      if params[:help]
+        output.print help
+        exit
+      elsif params[:version]
+        output.puts VERSION
+        exit
+      elsif params.errors.any?
+        output.puts params.errors.summary
+        exit 1
+      else
+        level = LEVELS[params[:level]]
+        decorator = Pastel.new(enabled: color).method(:decorate)
+        game = Game.new(
+          input: input,
+          output: output,
+          env: env,
+          width: params[:width] || level[:width],
+          height: params[:height] || level[:height],
+          screen_width: screen_width,
+          screen_height: screen_height,
+          mines_limit: params[:mines] || level[:mines],
+          decorator: decorator
+        )
+        game.run
+      end
+    rescue Minehunter::Error => err
+      output.puts "Error: #{err}"
+      exit 1
+    end
+  end # CLI
+end # Minehunter

data/lib/minehunter/field.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Minehunter
+  # A field on a gird representation
+  #
+  # @api private
+  class Field
+    BOMB = "*"
+    COVER = "░"
+    EMPTY = " "
+    FLAG = "F"
+    WRONG = "X"
+
+    # Mappings of mine counts to colour names
+    MINE_COUNT_TO_COLOR = {
+      1 => :cyan,
+      2 => :green,
+      3 => :red,
+      4 => :blue,
+      5 => :magenta,
+      6 => :yellow,
+      7 => :bright_cyan,
+      8 => :bright_green
+    }.freeze
+
+    # The number of mines in nearby fields
+    #
+    # @api public
+    attr_accessor :mine_count
+
+    # Create a Field instance
+    #
+    # @api public
+    def initialize
+      @flag = false
+      @mine = false
+      @cover = true
+      @wrong = false
+      @mine_count = 0
+    end
+
+    # Toggle flag for a covered field
+    #
+    # @api public
+    def flag
+      return unless cover?
+
+      @flag = !@flag
+    end
+
+    # Whether or not there is a flag placed
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def flag?
+      @flag
+    end
+
+    # Mark as having a mine
+    #
+    # @api public
+    def mine!
+      @mine = true
+    end
+
+    # Whether or not the field has mine
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def mine?
+      @mine
+    end
+
+    # Uncover this field
+    #
+    # @api public
+    def uncover
+      @cover = false
+    end
+
+    # Whether or not the field has cover
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def cover?
+      @cover
+    end
+
+    # Mark as having wrongly placed flag
+    #
+    # @api public
+    def wrong
+      @wrong = true
+    end
+
+    # Whether or not a flag is placed wrongly
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def wrong?
+      @wrong
+    end
+
+    # Render the field
+    #
+    # @param [Proc] decorator
+    #   apply style formatting
+    #
+    # @return [String]
+    #
+    # @api public
+    def render(decorator: DEFAULT_DECORATOR)
+      if !cover?
+        if mine? then BOMB
+        elsif flag? && wrong? then decorator[WRONG, :on_red]
+        elsif !mine_count.zero?
+          decorator[mine_count.to_s, MINE_COUNT_TO_COLOR[mine_count]]
+        else EMPTY end
+      elsif flag? then FLAG
+      else COVER end
+    end
+  end # Field
+end # Minehunter

data/lib/minehunter/game.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require "tty-box"
+require "tty-cursor"
+require "tty-reader"
+
+require_relative "grid"
+require_relative "intro"
+
+module Minehunter
+  # Responsible for playing mine hunting game
+  #
+  # @api public
+  class Game
+    # The keys to exit game
+    #
+    # @api private
+    EXIT_KEYS = [?\C-x, "q", "\e"].freeze
+
+    # The terminal cursor clearing and positioning
+    #
+    # @api public
+    attr_reader :cursor
+
+    # Create a Game instance
+    #
+    # @param [IO] input
+    #   the input stream, defaults to stdin
+    # @param [IO] output
+    #   the output stream, defaults to stdout
+    # @param [Hash] env
+    #   the environment variables
+    # @param [Integer] width
+    #   the number of columns
+    # @param [Integer] height
+    #   the number of rows
+    # @param [Integer] mines_limit
+    #   the total number of mines
+    # @param [Integer] screen_width
+    #   the terminal screen width
+    # @param [Integer] screen_height
+    #   the terminal screen height
+    # @param [Pastel] decorator
+    #   the decorator for styling
+    # @param [Proc] randomiser
+    #   the random number generator
+    #
+    # @api public
+    def initialize(input: $stdin, output: $stdout, env: {},
+                   width: nil, height: nil, mines_limit: nil,
+                   screen_width: nil, screen_height: nil,
+                   decorator: DEFAULT_DECORATOR, randomiser: DEFAULT_RANDOMISER)
+      @output = output
+      @width = width
+      @top = (screen_height - height - 4) / 2
+      @left = (screen_width - width - 4) / 2
+      @pos_x = (width - 1) / 2
+      @pos_y = (height - 1) / 2
+      @decorator = decorator
+      @randomiser = randomiser
+      @box = TTY::Box
+      @cursor = TTY::Cursor
+      @reader = TTY::Reader.new(input: input, output: output, env: env,
+                                interrupt: :exit)
+      @grid = Grid.new(width: width, height: height, mines_limit: mines_limit)
+      @intro = Intro
+      @intro_top = (screen_height - @intro.height - 2) / 2
+      @intro_left = (screen_width - @intro.width - 4) / 2
+
+      reset
+    end
+
+    # Reset game
+    #
+    # @api public
+    def reset
+      @curr_x = @pos_x
+      @curr_y = @pos_y
+      @first_uncover = true
+      @lost = false
+      @stop = false
+      @grid.reset
+    end
+
+    # Check whether or not the game is finished
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def finished?
+      @lost || @grid.cleared?
+    end
+
+    # Start the game
+    #
+    # @api public
+    def run
+      @output.print cursor.hide + cursor.clear_screen + render_intro_box
+      pressed_key = @reader.read_keypress
+      keyctrl_x if EXIT_KEYS.include?(pressed_key)
+
+      @output.print cursor.clear_screen
+      @reader.subscribe(self)
+
+      until @stop
+        @output.print render_status_box + render_grid_box
+        @reader.read_keypress
+      end
+    ensure
+      @output.print cursor.show
+    end
+
+    # Render box with intro
+    #
+    # @return [String]
+    #
+    # @api private
+    def render_intro_box
+      @box.frame(
+        @intro.render,
+        top: @intro_top,
+        left: @intro_left,
+        padding: [0, 1]
+      )
+    end
+
+    # Render box with status message
+    #
+    # @return [String]
+    #
+    # @api private
+    def render_status_box
+      @box.frame(
+        status,
+        top: @top,
+        left: @left,
+        width: @width + 4,
+        padding: [0, 1],
+        border: {bottom: false},
+        align: :center
+      )
+    end
+
+    # Render box with grid
+    #
+    # @return [String]
+    #
+    # @api private
+    def render_grid_box
+      @box.frame(
+        render_grid,
+        top: @top + 2,
+        left: @left,
+        padding: [0, 1],
+        border: {
+          top_left: :divider_right,
+          top_right: :divider_left
+        }
+      )
+    end
+
+    # Status message
+    #
+    # @return [String]
+    #
+    # @api public
+    def status
+      if @lost
+        "GAME OVER"
+      elsif @grid.cleared?
+        "YOU WIN"
+      else
+        "Flags #{@grid.flags_remaining}"
+      end
+    end
+
+    # Render grid with current position marker
+    #
+    # @api private
+    def render_grid
+      @grid.render(@curr_x, @curr_y, decorator: @decorator)
+    end
+
+    # Control game movement and actions
+    #
+    # @param [TTY::Reader::KeyEvent] event
+    #   the keypress event
+    #
+    # @api private
+    def keypress(event)
+      case event.value.to_sym
+      when :h, :a then keyleft
+      when :l, :d then keyright
+      when :j, :s then keydown
+      when :k, :w then keyup
+      when :f, :g then flag
+      when :r then reset
+      when :q then keyctrl_x
+      end
+    end
+
+    # Place a flag
+    #
+    # @api private
+    def flag
+      return if finished?
+
+      @grid.flag(@curr_x, @curr_y) unless finished?
+    end
+
+    # Quit game
+    #
+    # @api private
+    def keyctrl_x(*)
+      @output.print cursor.clear_screen
+      @output.print cursor.move_to(0, 0)
+      @stop = true
+    end
+    alias keyescape keyctrl_x
+
+    # Uncover a field
+    #
+    # @api private
+    def keyspace(*)
+      return if @grid.flag?(@curr_x, @curr_y)
+
+      if @first_uncover
+        @grid.fill_with_mines(@curr_x, @curr_y, randomiser: @randomiser)
+        @first_uncover = false
+      end
+      @lost = @grid.uncover(@curr_x, @curr_y)
+    end
+    alias keyenter keyspace
+    alias keyreturn keyspace
+
+    # Move cursor up
+    #
+    # @api private
+    def keyup(*)
+      return if finished?
+
+      @curr_y = @grid.move_up(@curr_y)
+    end
+
+    # Move cursor down
+    #
+    # @api private
+    def keydown(*)
+      return if finished?
+
+      @curr_y = @grid.move_down(@curr_y)
+    end
+
+    # Move cursor left
+    #
+    # @api private
+    def keyleft(*)
+      return if finished?
+
+      @curr_x = @grid.move_left(@curr_x)
+    end
+
+    # Move cursor right
+    #
+    # @api private
+    def keyright(*)
+      return if finished?
+
+      @curr_x = @grid.move_right(@curr_x)
+    end
+  end # Game
+end # Minehunter