bloodymines 0.1.0

data/bin/bloodymines

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+# bloodymines -- the executable terminal script for the bloody_mines gem
+require File.dirname(__FILE__) + "/../lib/minefield"
+require "curses"
+include Curses
+
+module Curses
+  def self.program
+    main_screen = init_screen   # init curses
+    noecho                      # don't show what you type
+    trap(0) { echo }            # reactivate echo on exit
+    cbreak                      # turn off buffered input
+    curs_set(0)                 # hide cursor
+    main_screen.keypad = true   # cursor keys are real events
+    yield main_screen
+  end
+end
+
+class Game
+  attr_accessor :cursor_x, :cursor_y
+  attr_reader :mines, :x_max, :y_max
+  def initialize(space = 1, x_offset = 1, y_offset = 1)
+    @space, @x_offset, @y_offset = space, x_offset, y_offset
+    @cursor_x, @cursor_y = 0, 0
+
+    puts "Welcome to bloody mines!"
+    print "Select your difficulty: [1]beginner, [2]intermediate, [3]expert => "
+    difficulty = gets.chomp.to_i
+    difficulty = case difficulty
+                 when 2: :intermediate
+                 when 3: :expert
+                 else :beginner
+                 end
+    @mines = MineField.new(:difficulty => difficulty)
+    @x_max = @mines.fields.size - 1
+    @y_max = @mines.fields[0].size - 1
+  end
+
+  def score
+    score = 0
+    @mines.fields.each do |rows|
+      rows.each do |cell|
+        score += cell if cell.kind_of?(Integer)
+      end
+    end
+    score
+  end
+
+  def draw_field
+    clear
+    0.upto(@x_max) do |x|
+      0.upto(@y_max) do |y|
+        # curses swaps x and y
+        setpos(y + @y_offset, x + @x_offset + spacing(x, @space))
+        field = case @mines.fields[x][y]
+                when false, :mine: "."
+                when :boom: "X"
+                else @mines.fields[x][y].to_s
+                end
+        addstr(field)
+      end
+    end
+    draw_cursor
+    setpos(0, 1)
+    addstr("Score: #{score}")
+    setpos(@y_max + 3, 1)
+    addstr("Use the arrow keys to move around.\n Hit Space to reveal a field. Q or ESC quits the game.")
+    refresh
+  end
+
+  def spacing(x, space)
+    x * space
+  end
+
+  def draw_cursor
+    x = @cursor_x + @x_offset + spacing(@cursor_x, @space)
+    y = @cursor_y + @y_offset
+    setpos(y, x - 1)
+    addstr("[")
+    setpos(y, x + 1)
+    addstr("]")
+  end
+
+  def move(params={})
+    case params[:direction]
+    when :up
+      @cursor_y -= 1 if @cursor_y > 0
+    when :down
+      @cursor_y += 1 if @cursor_y < @y_max
+    when :left
+      @cursor_x -= 1 if @cursor_x > 0
+    when :right
+      @cursor_x += 1 if @cursor_x < @x_max
+    end
+  end
+
+  def ended?
+    uncovered = 0
+    @mines.fields.each do |rows|
+      rows.each do |cell|
+        uncovered += 1 if cell == false
+        return true if cell == :boom
+      end
+    end
+    return false if uncovered > 0
+    true
+  end
+end
+
+# curses app
+game = Game.new
+
+Curses.program do |scr|
+  while true
+    game.draw_field
+    case getch
+    when Key::UP
+      game.move(:direction => :up, :type => :movement)
+    when Key::DOWN
+      game.move(:direction => :down, :type => :movement)
+    when Key::LEFT
+      game.move(:direction => :left, :type => :movement)
+    when Key::RIGHT
+      game.move(:direction => :right, :type => :movement)
+    when 32
+      game.mines.uncover_field(game.cursor_x, game.cursor_y)
+    when 27, ?q, ?Q
+      break
+    end
+    if game.ended?
+      game.draw_field
+      setpos(0, 1)
+      addstr("Game Over. Hit any key to quit.")
+      getch
+      break
+    end
+  end
+ close_screen
+ puts "Your final score was: #{game.score}"
+end

data/lib/minefield.rb

@@ -0,0 +1,55 @@
+class MineField
+  attr_accessor :fields, :difficulty
+
+  BEGINNER_WIDTH, BEGINNER_HEIGHT, BEGINNER_MINES = 8, 8, 10
+  INTERMEDIATE_WIDTH, INTERMEDIATE_HEIGHT, INTERMEDIATE_MINES = 16, 16, 40
+  EXPERT_WIDTH, EXPERT_HEIGHT, EXPERT_MINES = 30, 16, 99
+
+  def initialize(params={})
+    params = { :difficulty => :beginner }.merge params
+    @difficulty = params[:difficulty]
+    case @difficulty
+    when :intermediate: @fields = create_fields(INTERMEDIATE_WIDTH, INTERMEDIATE_HEIGHT, INTERMEDIATE_MINES)
+    when :expert: @fields = create_fields( EXPERT_WIDTH, EXPERT_HEIGHT, EXPERT_MINES)
+    else @fields = create_fields(BEGINNER_WIDTH, BEGINNER_HEIGHT, BEGINNER_MINES)
+    end
+  end
+
+  def create_fields(width, height, mines)
+    fields = Array.new(width) { Array.new(height, false) }
+    while(mines > 0) do
+      x = rand(width)
+      y = rand(height)
+      unless (fields[x][y] == :mine)
+        fields[x][y] = :mine
+        mines -= 1
+      end
+    end
+    fields
+  end
+
+  def adjacent_mines(x, y)
+    return false if @fields[x][y] == :mine || @fields[x][y] == :boom
+    coords = []
+    coords << [x-1, y] << [x+1, y] << [x, y-1] << [x, y+1] << [x-1, y-1] << [x-1, y+1] << [x+1, y-1] << [x+1, y+1]
+    # reject the coordinates that bleed over the edges of the playfield
+    coords = coords.reject do |x, y|
+      x < 0 || y < 0 || x > @fields.size - 1 || y > @fields[0].size - 1
+    end
+    mines = 0
+    coords.each do |x, y|
+      mines += 1 if @fields[x][y] == :mine || @fields[x][y] == :boom
+    end
+    mines
+  end
+
+  def uncover_field(x, y)
+    field = adjacent_mines(x, y)
+    if field
+      @fields[x][y] = field
+    else
+      @fields[x][y] = :boom
+    end
+    field
+  end
+end

data/test/test_minefield.rb

@@ -0,0 +1,70 @@
+require "rubygems"
+require "shoulda"
+require "test/unit"
+
+require File.dirname(__FILE__) + "/../lib/minefield"
+
+class TestMineField < Test::Unit::TestCase
+  def setup
+    @beginner = MineField.new(:difficulty => :beginner)
+    @intermediate = MineField.new(:difficulty => :intermediate)
+    @expert = MineField.new(:difficulty => :expert)
+  end
+
+  should "have the MineField class defined" do
+    mines = MineField.new
+  end
+
+  should "have a readable attribute :difficulty" do
+    assert(MineField.new.difficulty)
+  end
+
+  should "default difficulty to beginner" do
+    assert_equal(:beginner, MineField.new.difficulty)
+  end
+
+  should "store difficulties correctly" do
+    assert_equal(:beginner, MineField.new(:difficulty => :beginner).difficulty)
+    assert_equal(:intermediate, MineField.new(:difficulty => :intermediate).difficulty)
+    assert_equal(:expert, MineField.new(:difficulty => :expert).difficulty)
+  end
+
+  should "have the right amount of mines at the difficulty level" do
+    assert_equal(10, count_mines(@beginner))
+    assert_equal(40, count_mines(@intermediate))
+    assert_equal(99, count_mines(@expert))
+    assert_equal(30, @expert.fields.size)
+    assert_equal(16, @expert.fields[0].size)
+  end
+
+  should "return false if the field is occupied by a mine" do
+    @beginner.fields[0][0] = :mine
+    assert_equal(:mine, @beginner.fields[0][0])
+    assert_equal(false, @beginner.adjacent_mines(0, 0))
+  end
+  should "calculate adjacent mines for corner fields correctly" do
+    @beginner.fields[0][0] = false
+    @beginner.fields[0][1] = :mine
+    @beginner.fields[1][0] = false
+    @beginner.fields[1][1] = false
+    @beginner.fields[7][0] = :mine
+    assert_equal(1, @beginner.adjacent_mines(0, 0))
+  end
+
+  should "uncover a field" do
+    @beginner.uncover_field(3, 4)
+    puts ""
+    @beginner.fields.each {|column| p column }
+  end
+
+  def count_mines(minefield)
+    mines = 0
+    minefield.fields.each do |x|
+      x.each do |y|
+        mines += 1 if y == :mine
+      end
+    end
+    mines
+  end
+
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: bloodymines
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- !binary |
+  w5Ztw7xyIMOWemtpcg==
+
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-17 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Play a minesweeper-like game in your terminal
+email: darkoem@gmal.com
+executables: 
+- bloodymines
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/minefield.rb
+- test/test_minefield.rb
+- bin/bloodymines
+has_rdoc: true
+homepage: http://darkno.de
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A minesweeper-like game.
+test_files: []
+