greed_game 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+# Ignore all copies of files
+*~

data/.rspec

@@ -0,0 +1 @@
+--colour --format documentation

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3-head@greed_game-gem

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 natalili
+
+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,97 @@
+# GreedGame
+
+= Playing Greed
+
+Greed is a dice game played among 2 or more players, using 5
+six-sided dice.
+
+== Playing Greed
+
+Each player takes a turn consisting of one or more rolls of the dice.
+On the first roll of the game, a player rolls all five dice which are
+scored according to the following:
+
+  Three 1's => 1000 points
+  Three 6's =>  600 points
+  Three 5's =>  500 points
+  Three 4's =>  400 points
+  Three 3's =>  300 points
+  Three 2's =>  200 points
+  One   1   =>  100 points
+  One   5   =>   50 points
+
+A single die can only be counted once in each roll.  For example,
+a "5" can only count as part of a triplet (contributing to the 500
+points) or as a single 50 points, but not both in the same roll.
+
+Example Scoring
+
+   Throw       Score
+   ---------   ------------------
+   5 1 3 4 1   50 + 2 * 100 = 250
+   1 1 1 3 1   1000 + 100 = 1100
+   2 4 4 5 4   400 + 50 = 450
+
+The dice not contributing to the score are called the non-scoring
+dice.  "3" and "4" are non-scoring dice in the first example.  "3" is
+a non-scoring die in the second, and "2" is a non-score die in the
+final example.
+
+After a player rolls and the score is calculated, the scoring dice are
+removed and the player has the option of rolling again using only the
+non-scoring dice. If all of the thrown dice are scoring, then the
+player may roll all 5 dice in the next roll.
+
+The player may continue to roll as long as each roll scores points. If
+a roll has zero points, then the player loses not only their turn, but
+also accumulated score for that turn. If a player decides to stop
+rolling before rolling a zero-point roll, then the accumulated points
+for the turn is added to his total score.
+
+== Getting "In The Game"
+
+Before a player is allowed to accumulate points, they must get at
+least 300 points in a single turn. Once they have achieved 300 points
+in a single turn, the points earned in that turn and each following
+turn will be counted toward their total score.
+
+== End Game
+
+Once a player reaches 3000 (or more) points, the game enters the final
+round where each of the other players gets one more turn. The winner
+is the player with the highest score after the final round.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'greed_game'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install greed_game
+
+## Usage
+
+1. Include this gem in class.
+2. Create class's object:
+    `game = My_class.new("player1", "player2",...)`
+    "player1", "player2",...  - player's names
+3. Begin the game:
+    `game.in_progress`
+4. Get a winner:
+    `game.finished`
+5. `next_roll?` method can accept/reject (return true/false) it next roll
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/greed_game.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/greed_game/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["natalili"]
+  gem.email         = ["natali.li@list.ru"]
+  gem.description   = %q{Greed is a dice game played among 2 or more players, using 5 six-sided dice.}
+  gem.summary       = %q{Greed is a dice game}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "greed_game"
+  gem.require_paths = ["lib"]
+  gem.version       = GreedGame::VERSION
+
+  gem.add_development_dependency "rspec"
+end

data/lib/greed_game/dice_set.rb

@@ -0,0 +1,8 @@
+ class DiceSet
+   def roll(argument)
+     @values = Array.new(argument){ rand(6)+1 } 
+   end
+    def values
+      @values
+    end
+ end

data/lib/greed_game/player.rb

@@ -0,0 +1,94 @@
+class Player
+  
+  attr_reader :score_roll, :score_total
+  attr_accessor :name
+  
+  def initialize(name)
+    @name = name
+    @score_roll = 0
+    @score_total = 0
+  end
+  
+  def calculate_non_scoring_dice(dice)
+    @count = dice.count
+    dice.uniq.each do |n|
+      if n == 1
+        @count = @count - dice.count(1)
+      elsif n == 5
+        @count = @count - dice.count(5)
+      else
+        @count = @count - 3 if dice.count(n) >= 3
+      end
+    end
+    @count
+  end
+  
+  def calculate_dice_for_next_roll(dice)
+    calculate_non_scoring_dice(dice)
+    if @count == 0 and dice.count > 0
+      @count = 5
+    elsif @count == dice.count
+      @count = 0
+    end
+    @count = 0 unless next_roll?
+    @count
+  end
+  
+  def next_roll?
+    if @count > 0
+      puts "Player #{name}, You have #{@score} score and You can use #{@count} dice. \n" +
+	   "If You want do roll, enter 'y'"
+      answer = STDIN.gets.chop!
+      answer == "y"
+    else
+      false
+    end
+  end
+  
+  def score(dice)
+    @score = 0
+    dice.uniq.each do |n|
+      if n == 1
+        c = dice.count(1)
+        @score += 100 * dice.count(1) if c < 3
+        @score += 1000 + 100 * (c - 3) if  c >= 3
+      elsif n == 5
+        c = dice.count(5)
+        @score += 50 * c if c < 3
+        @score += 5  * 100 + 50 * (c - 3) if c >= 3
+      else
+        c = dice.count(n)
+        @score += n * 100 if c >= 3
+      end
+    end
+    @score
+  end
+  
+  def calculate_score_roll(score)
+    score == 0 ? @score_roll = 0 : @score_roll += score
+    @score = 0
+    @score_roll
+  end
+  
+  def calculate_score_total(score_roll)
+    if @score_total == 0
+      @score_total += score_roll if score_roll >= 300
+    else
+      @score_total += score_roll      
+    end
+    @score_roll = 0
+    @score_total
+  end
+  
+  def roll(dices)
+    while dices > 0 
+      dice_set = DiceSet.new
+      dice_roll = dice_set.roll(dices)
+      score = score(dice_roll)
+      dices = calculate_dice_for_next_roll(dice_roll)
+      score_roll = calculate_score_roll(score)
+      calculate_score_total(score_roll) if dices == 0
+    end
+  end
+
+end

data/lib/greed_game/version.rb

@@ -0,0 +1,3 @@
+module GreedGame
+  VERSION = "0.0.1"
+end

data/lib/greed_game.rb

@@ -0,0 +1,47 @@
+require "greed_game/version"
+require "greed_game/dice_set"
+require "greed_game/player"
+
+module GreedGame
+
+  def self.name
+    "Greed Game"
+  end
+  
+  def initialize(*names)
+    raise "It should be 2 or more players in the game" if names.size < 2
+    @dices = 5
+    @players = Array.new
+    names.each do |name|
+      @players << Player.new(name)
+    end
+  end
+  
+  def in_progress
+    max_score = 0
+    last_round = false
+    while  max_score < 3000 or not last_round
+      @players.each do |player|
+        player.roll(@dices)
+      end
+      player_whith_max_score = @players.max_by {|players| players.score_total }
+      last_round = true if max_score >= 3000
+      max_score = player_whith_max_score.score_total
+    end
+    @winner = Array.new
+    @players.each do |player|
+      @winner << player if player.score_total == max_score
+    end
+    @winner
+  end
+  
+  def finished
+    if @winner.count == 1
+      text = "#{@winner[0].name} is winner"
+    else
+      text = "Winner is absent"
+    end
+    text
+  end
+
+end

data/spec/dice_set_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe DiceSet do
+  before(:each) {@dice = DiceSet.new; @dice.roll(5)}
+  
+  
+  it "should create a dice set" do
+    @dice.should_not be_nil
+  end
+  
+  it "should be an array" do
+    @dice.values.should be_is_a(Array)
+  end
+  
+  it "should have valid array size" do
+    @dice.values.size.should == 5
+  end
+
+  it "should return a set of integers between 1 and 6" do
+    @dice.values.each do |value|
+      value.should >= 1 && value.should <= 6
+    end
+  end
+  
+  it "values should not change unless dice explicitly rolled" do
+    first_time = @dice.values
+    second_time = @dice.values
+    second_time.should == first_time
+  end
+  
+  it "rolls should change dice values" do
+    first_time = @dice.values
+    @dice.roll(5)
+    second_time = @dice.values
+    second_time.should_not == first_time
+  end
+  
+  it "should can roll different numbers of dice" do
+    @dice.values.size.should == 5
+    @dice.roll(3)
+    @dice.values.size.should == 3
+    @dice.roll(1)
+    @dice.values.size.should == 1
+  end
+end

data/spec/greed_game_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe GreedGame do
+  before(:each) do
+    class Game
+      include GreedGame
+    end
+    @game = Game.new("player1", "player2")
+  end
+    
+  context "#name" do
+    it "shuld return gem name" do
+      GreedGame.name.should == "Greed Game"
+    end
+  end
+  
+  context "New" do
+    it "should create game with 2 or more players" do
+      @game.instance_variable_get(:@players).size.should == 2
+      @game = Game.new("player1", "player2", "player3")
+      @game.instance_variable_get(:@players).size.should == 3
+    end
+    
+    it "should rise exception with 1 player" do
+      expect { Game.new("player1") }.to raise_error('It should be 2 or more players in the game')
+    end
+
+    it "should use 5 dices" do
+      @game.instance_variable_get(:@dices).should == 5
+    end
+    
+    it "should have score total is zero" do
+      @game.instance_variable_get(:@players).max_by {|players| players.score_total }.score_total. should == 0
+    end
+  end
+    
+  context "In progress" do
+  before(:each) {@game.instance_variable_get(:@players)[0].stub!(:next_roll?).and_return(false)
+                 @game.instance_variable_get(:@players)[1].stub!(:next_roll?).and_return(false)}
+    
+    it "should have a player with score total is more 3000" do
+      @game.in_progress
+      @game.instance_variable_get(:@players).max_by {|players| players.score_total }.score_total. should >= 3000
+    end
+    
+    it "should return array with winners" do
+      @game.in_progress.should_not == []
+      @game.instance_variable_get(:@winner).count.should > 0
+    end
+
+    it "should return player with maximal score total" do
+      @game.instance_variable_get(:@players)[0].stub!(:score_total).and_return(30000)
+      @game.in_progress[0].name.should == "player1"
+      @game.instance_variable_get(:@winner)[0].name.should == "player1"
+      @game.instance_variable_get(:@winner).count.should == 1
+    end
+  end
+  
+  context "Finished" do
+    
+    it "should return who is winner if one player have maximal score total" do
+      @game.instance_variable_set(:@winner , Array.new << Player.new("player1"))
+      @game.finished.should == "player1 is winner"
+    end
+    
+    it "should return 'Winner is absent' if array with winners is empty" do
+      @game.instance_variable_set(:@winner, Array.new)
+      @game.finished.should == "Winner is absent"
+    end
+
+    it "should return 'Winner is absent' if more than one player have maximal score total" do
+      @game.instance_variable_set(:@winner, @game.instance_variable_get(:@players))
+      @game.finished.should == "Winner is absent"
+    end
+
+  end
+end

data/spec/player_spec.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+
+describe Player do
+  before(:each) {@player = Player.new("player1")}
+  
+  context "New" do
+    
+    it "should have a name" do
+      @player.instance_variables.include?(:@name).should == true
+    end
+  
+    it "should return a name" do
+      @player.name.should == "player1"
+    end
+  
+    it "should set name" do
+      @player.name = "Player 1"
+      @player.name.should == "Player 1"
+    end
+  
+    it "should have a current roll's score" do
+      @player.instance_variables.include?(:@score_roll).should == true
+    end
+  
+    it "should have zero roll's score" do
+      @player.score_roll.should == 0
+    end
+
+    it "should rise exception if roll's score is set" do
+      expect { @player.score_roll = 300 }.to raise_error(NoMethodError)    
+    end
+  
+    it "should have total score" do
+      @player.instance_variables.include?(:@score_total).should == true
+    end
+  
+    it "should have zero total score" do
+      @player.score_total.should == 0
+    end
+  
+    it "should rise exception if total score is set" do
+      expect { @player.score_total = 3000 }.to raise_error(NoMethodError)    
+    end
+  end
+  
+  context "Calculate non-scoring dices" do
+    
+      it "should be zero if dices are absent" do
+	@player.calculate_non_scoring_dice([]).should == 0
+      end
+      
+      it "should be zero if all of the thrown dices are scoring" do
+	@player.calculate_non_scoring_dice([5]).should == 0
+	@player.calculate_non_scoring_dice([1]).should == 0
+	@player.calculate_non_scoring_dice([2,2,2]).should == 0
+	@player.calculate_non_scoring_dice([3,3,3]).should == 0
+	@player.calculate_non_scoring_dice([4,4,4]).should == 0
+	@player.calculate_non_scoring_dice([6,6,6]).should == 0
+	@player.calculate_non_scoring_dice([1,5,3,3,3]).should == 0
+      end
+      
+      it "should return the count of 2s, 3s, 4s, and 6s" do
+	@player.calculate_non_scoring_dice([2,3,4,6]).should == 4
+      end
+      
+      it "should return the count of non-scoring dices for mixed dice sets" do
+	@player.calculate_non_scoring_dice([2,2,2,3,4]).should == 2
+	@player.calculate_non_scoring_dice([1,5,6,4,2]).should == 3
+      end
+  
+  end
+  
+  context "Calculate count of dices for next roll" do
+  before(:each) {@player.stub!(:next_roll?).and_return(true)}
+    
+      it "should be zero if dices are absent" do
+	@player.calculate_dice_for_next_roll([]).should == 0
+      end
+      
+      it "should be 5 if all of the thrown dices are scoring" do
+	@player.calculate_dice_for_next_roll([1]).should == 5
+	@player.calculate_dice_for_next_roll([3,3,3]).should == 5
+	@player.calculate_dice_for_next_roll([5,5,4,4,4]).should == 5
+      end
+      
+      it "should be zero for 2s, 3s, 4s, and 6s" do
+	@player.calculate_dice_for_next_roll([2,3,4,6,4]).should == 0
+      end
+      
+      it "should return the count of dices for mixed dice sets" do
+	@player.calculate_dice_for_next_roll([3,2,2,2]).should == 1
+	@player.calculate_dice_for_next_roll([4,2,5,1,1]).should == 2
+      end
+      
+  end
+  
+  context "Next roll?" do
+
+    it "should return false if player not have dices for next roll" do 
+      @player.instance_variable_set("@count", 0)
+      @player.should_not be_next_roll
+    end
+    
+    it "should return true if player enter 'y'" do 
+      @player.instance_variable_set("@count", 1)
+      STDIN.stub!(:gets).and_return("y\n")
+      @player.should be_next_roll
+    end
+    
+    it "should return false if player enter not 'y'" do 
+      @player.instance_variable_set("@count", 1)
+      STDIN.stub!(:gets).and_return("")
+      @player.should_not be_next_roll
+    end
+    
+  end
+  
+  describe "Score" do
+    context "For dice" do
+      
+      it "should be zero if dices are absent" do
+	@player.score([]).should == 0
+      end
+      
+      it "should be 50 for single roll of 5" do
+	@player.score([5]).should == 50
+      end
+      
+      it "should be 100 for single roll of 1" do
+	@player.score([1]).should == 100
+      end
+      
+      it "should return the sum of individual scores for multiple 1s and 5s" do
+	@player.score([1,5,5,1]).should == 300
+      end
+      
+      it "should be zero for single 2s, 3s, 4s, and 6s" do
+	@player.score([2,3,4,6]).should == 0
+      end
+      
+      it "should be 1000 for a triple 1" do
+	@player.score([1,1,1]).should == 1000
+      end
+      
+      it "should return 100x for other triples" do
+	@player.score([2,2,2]).should == 200
+	@player.score([3,3,3]).should == 300
+	@player.score([4,4,4]).should == 400
+	@player.score([5,5,5]).should == 500
+	@player.score([6,6,6]).should == 600
+      end
+      
+      it "should return sum for mixed dice sets" do
+	@player.score([2,5,2,2,3]).should == 250
+	@player.score([5,5,5,5]).should == 550
+      end
+      
+    end
+    
+    context "Roll's" do
+      
+      it "should be zero for new player" do
+	@player.score_roll.should == 0
+      end
+      
+      it "should be zero if score is zero" do
+	@player.calculate_score_roll(0).should == 0
+	@player.score_roll.should == 0
+      end
+    
+      it "should increase by score for dice" do
+	score = @player.score([1])
+	expect { @player.calculate_score_roll(score) }.to change{ @player.score_roll }.by(score)
+      end
+      
+      it "should set zero for score" do
+	@player.calculate_score_roll(0)
+	@player.instance_variable_get("@score").should == 0
+	@player.calculate_score_roll(100)
+	@player.instance_variable_get("@score").should == 0
+      end
+      
+    end
+    
+    context "Total" do
+      
+      it "should be zero for new player" do
+	@player.score_total.should == 0
+      end
+
+      it "should not increase if total score is zero and roll's score less than 300" do
+	expect { @player.calculate_score_total(250) }.to_not change{ @player.score_total }
+      end
+
+      it "should increase if total score is zero and roll's score equal 300" do
+	expect { @player.calculate_score_total(300) }.to change{ @player.score_total }.by(300)
+      end
+
+      it "should increase if total score is zero and roll's score more than 300" do
+	expect { @player.calculate_score_total(400) }.to change{ @player.score_total }.by(400)
+      end
+      
+      it "should increase if total score more than zero and roll's score more than zero" do
+        @player.instance_variable_set(:@score_total, 500)
+        expect{ @player.calculate_score_total(200) }.to change{ @player.score_total }.from(500).to(700)
+      end
+
+      it "should set zero for roll's score" do
+	@player.calculate_score_total(0)
+	@player.instance_variable_get("@score_roll").should == 0
+	@player.calculate_score_total(300)
+	@player.instance_variable_get("@score_roll").should == 0
+      end
+
+    end
+  end
+    
+  context "Roll" do
+      
+    it "should not increase score total if dices are absent" do
+      dices = 0
+      expect { @player.roll(dices) }.to_not change{ @player.score_total }
+    end
+      
+    it "should increase score total if amount dices more than zero" do
+      dices = 5
+      @player.instance_variable_set(:@score_total, 500)
+      @player.stub!(:calculate_dice_for_next_roll).and_return(0)
+      @player.stub!(:calculate_score_roll).and_return(200)
+      expect{ @player.roll(dices) }.to change{ @player.score_total }.from(500).to(700)
+    end
+      
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'greed_game'
+require 'greed_game/dice_set'
+require 'greed_game/player'

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: greed_game
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- natalili
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &77735400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *77735400
+description: Greed is a dice game played among 2 or more players, using 5 six-sided
+  dice.
+email:
+- natali.li@list.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- greed_game.gemspec
+- lib/greed_game.rb
+- lib/greed_game/dice_set.rb
+- lib/greed_game/player.rb
+- lib/greed_game/version.rb
+- spec/dice_set_spec.rb
+- spec/greed_game_spec.rb
+- spec/player_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Greed is a dice game
+test_files:
+- spec/dice_set_spec.rb
+- spec/greed_game_spec.rb
+- spec/player_spec.rb
+- spec/spec_helper.rb