Ruby_Dice 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b9b75ef4c4911ce1114a5f5fc95bd85dedeef93c
+  data.tar.gz: 208d27f1d71d807e2be51f966dd2260f41da09e5
+SHA512:
+  metadata.gz: 5df78bac00770e5ec9b1b5d7e2bbc1bdf2a10e4bc35d337a2a4794f0c703c1e36cb26f12e2b93de7d12e2682afc9f9c7225adc432a4f5c3346f898878c87fdc6
+  data.tar.gz: 81850e8ce27a0f54bfbf74abdf3402832faaf4eaee53a0c3b08f253ba9dec64432d9ca3609d997641406bdd3aa05bdd7f2acc258c8ce97fb1f8a7174f2bd48a1

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Mario Martinez and Zachary Perlmutter
+
+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,11 @@
+# Ruby_Dice
+A Yahtzee clone written in Ruby that runs in the terminal
+
+This project is a personal project for educational purposes and becoming accustomed to the Ruby programming paradigm. Furthermore, it's to become accustomed to the Git workflow. Contributions are most welcome!
+## Badges
+[![Inline docs](http://inch-ci.org/github/martimatix/Ruby-Dice.svg?branch=master)](http://inch-ci.org/github/martimatix/Ruby-Dice)
+[![Code Climate](https://codeclimate.com/github/martimatix/Ruby-Dice/badges/gpa.svg)](https://codeclimate.com/github/martimatix/Ruby-Dice)
+[![Build Status](https://travis-ci.org/martimatix/Ruby-Dice.svg)](https://travis-ci.org/martimatix/Ruby-Dice)
+[![Test Coverage](https://codeclimate.com/github/martimatix/Ruby-Dice/badges/coverage.svg)](https://codeclimate.com/github/martimatix/Ruby-Dice)
+## Docs
+* [rubydoc.info](http://www.rubydoc.info/github/martimatix/Ruby-Dice/master)

data/bin/Ruby_Dice

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+BEGIN {
+  if ARGV.include? "-h"
+    puts <<HELP
+Usage: $ Ruby_Dice [--help]
+\u00B7 --help -> Displays this help message
+
+Gameplay:
+	Abbreviations:
+	\u00B7 1	->	Ones 
+	\u00B7 2	->	Twos 
+	\u00B7 3	->	Threes
+	\u00B7 4	->	Fours 
+	\u00B7 5	->	Fives 
+	\u00B7 6	->	Sixes 
+	\u00B7 ss	->	Small Straight 
+	\u00B7 ls	->	Large Straight 
+	\u00B7 tok	->	Three Of A Kind 
+	\u00B7 fok	->	Four Of A Kind 
+	\u00B7 fh 	-> 	Full House 
+	\u00B7 y 	->	Yahtzee 
+	\u00B7 ?	->	chance
+HELP
+    exit
+  end
+}
+
+require "Ruby_Dice"
+
+user = Player.new
+
+until user.score.filled? do
+	puts ?\n
+	puts "New Turn".center(80)
+	puts ?\n
+	sleep 0.5
+	user.take_turn
+end

data/lib/Ruby_Dice.rb

@@ -0,0 +1,4 @@
+autoload :Dice, "dice"
+autoload :Player, "player"
+autoload :ScoreSheet, "scoresheet"
+autoload :Scoring, "scoring"

data/lib/dice.rb

@@ -0,0 +1,59 @@
+class Dice  # Class for working with the 5 dice at the same time
+
+	attr_reader :values # @return [Array] the dice.
+
+	def initialize(values=Array.new(5) {new_dice}) # @param values [Array<Fixnum>] that contains 5 Fixnums
+		check_dice values
+		@values = values
+	end 
+
+# @!group Roll Methods
+
+=begin
+@raise [ArgumentError] if i element > 4
+@return [void]
+@param i [Array<Fixnum>] < 4
+=end
+	def roll(dice_to_roll)
+		for index in dice_to_roll
+			raise ArgumentError, "Illegal index" if index > 4
+			@values[index] = new_dice
+		end
+	end 
+	
+=begin
+@note Rolls all the dice
+
+@return [void]
+=end
+	def roll_all; initialize; end
+
+# @!endgroup
+
+	def to_s # @return [String] instance variable dice
+		print @values
+	end
+	alias display to_s
+
+=begin
+@param values [Array<Integer>]
+@see (#check_dice)
+@note setting dice for values for testing
+@!parse attr_writer :values
+=end
+	def values=(values)
+		check_dice values
+		@values = values
+	end
+
+	private 
+	def new_dice; return (1..6).to_a.sample; end # @return [Fixnum] a random number between 1 and 6, inclusive
+=begin
+@param dice [Array<Fixnum>]
+@return [void]
+@raise [ArgumentError] if dice does not meet expectations
+=end
+	def check_dice(dice)
+		raise(ArgumentError, "Array must have 5 Integers that are between 1 and 6") unless dice.length == 5 && dice.all? {|val| (val.is_a? Fixnum) && (val.between? 1,6)}
+	end
+end

data/lib/player.rb

@@ -0,0 +1,90 @@
+require_relative "scoresheet.rb"
+require 'set'
+
+class Player
+	
+	ScoreAbbr = { # Abbreviations used in-game
+		?1.to_sym => :ones,
+		?2.to_sym => :twos,
+		?3.to_sym => :threes,
+		?4.to_sym => :fours,
+		?5.to_sym => :fives,
+		?6.to_sym => :sixes,
+		ss: :small_straight,
+		ls: :large_straight,
+		tok: :three_of_a_kind,
+		fok: :four_of_a_kind,
+		fh: :full_house,
+		y: :yahtzee,
+		"?".to_sym => :chance
+	}
+
+	attr_reader :score # @return [ScoreSheet]
+
+	def initialize
+		@score = ScoreSheet.new
+	end
+
+=begin
+@todo finish method
+@return [void]
+=end
+	def take_turn
+		turn_over = false
+		(1..3).each do |i|
+			display_dice i
+			turn_over = user_input i 
+			break if turn_over
+		end
+	end
+
+	def display_dice(i)
+		sleep 0.5
+		puts String.new.center(80, ?-) 
+		puts "Here are your dice. You have have #{3-i} #{i==2? "roll":"rolls"} remaining.\n\n"
+		puts "\tDice\t\tZ\tX\tC\tV\tB"
+		puts "\tValues\t\t" + score.dice.values.map{|value| value.to_s}.join(?\t)
+		puts String.new.center(80, ?-)
+	end
+	
+=begin
+@param i [Fixnum] Amount of times rolled
+@return [Boolean]
+@note Gameplay
+=end
+	def user_input(i)
+		if i < 3
+			print "Select dice to re-roll or select a score category: "
+		else
+			print "No rolls remaining. Select a score category: "
+		end
+		input = gets.chomp.downcase
+		input_symbol = input.to_sym
+		user_input = Set.new(input.split(''))
+		dice_controls = Set.new("zxcvb".split(''))
+
+		# If user wants to enter score
+		if ScoreAbbr.keys.include? input_symbol
+			score.enter_score ScoreAbbr[input_symbol]
+			puts score
+			@score.dice.roll_all
+			sleep 2
+			return true
+		# Else if user wants to roll the dice
+		elsif i < 3 && (user_input.subset? dice_controls)
+			dice_to_roll = (0..4).to_a.select { |index| input.include? dice_controls.to_a[index]}
+			@score.dice.roll(dice_to_roll)
+			sleep 0.5
+			2.times {puts ?\n}
+			puts " Rolling Dice!\ ".center 80, "* "
+			sleep 1
+			return false 
+		else
+			puts "Invalid input. Please try again."
+			sleep 1.5
+			puts ?\n
+			user_input i
+		end
+	end
+end
+ 

data/lib/scoresheet.rb

@@ -0,0 +1,156 @@
+require_relative "dice.rb"
+require_relative "scoring.rb"
+
+class ScoreSheet # Keeps score throughout the game
+	include Scoring
+
+	UpperScores = :ones, :twos, :threes, :fours, :fives, :sixes	# The fields on the top section of the score sheet
+	
+	LowerScores = :three_of_a_kind, :four_of_a_kind, :full_house, :small_straight, :large_straight, :chance, :yahtzee  # The fields on the bottom section of the score sheet
+
+	attr_reader :sheet	# @return [Hash] table of two element arrays where the first value is the score and the second is whether the field has been played
+	attr_reader :dice	# @return [Dice]
+	attr_reader :num_yahtzees	# @return [Fixnum] counter for number of yahtzees scored in the game
+=begin
+@param custom_dice [Array<Fixnum>] custom dice for testing
+=end
+	def initialize(custom_dice=Array.new(5) {Dice.new.instance_eval "new_dice"})
+		@sheet, @dice, @num_yahtzees = Hash.new, Dice.new(custom_dice), 0
+		Array.new(UpperScores).concat(LowerScores).each {|s| @sheet[s] = [0, false]}
+	end
+	
+=begin
+@param field [Symbol]
+@return [void]
+@raise ArgumentError
+=end
+	def enter_score(field)
+		if field == :yahtzee && ((available :yahtzee) || @num_yahtzees > 0)
+			@sheet[field] = yahtzee, true
+		elsif available field			
+			@sheet[field] = send(field, @dice.values), true
+		else
+			raise ArgumentError, "Score already entered."
+		end
+	end
+
+=begin
+@return [true] if the score sheet is completely filled and no legal moves remain
+@return [false] if the score sheet is not completely filled and there are still legal moves to be made
+=end
+	def filled?
+		@sheet.collect{|k,v| v[1]}.reduce{|r,e| r && e}
+	end
+	
+	def raw_upper	# @return [Fixnum]
+		@sheet.select{|x| UpperScores.include? x }.collect{|k,v| v[0]}.reduce :+
+	end	
+
+	def upper_score_total	# @return [Fixnum] the total score of the upper part of the ScoreSheet, including bonuses
+		raw_upper + upper_score_bonus
+	end
+	def lower_score_total	# @return [Integer] The total score of the lower part of the ScoreSheet
+		@sheet.select{|x| LowerScores.include? x }.collect{|k,v| v[0]}.reduce :+
+	end
+	def total	# @return [Integer] the grand total
+		lower_score_total + upper_score_total
+	end
+	
+
+
+=begin
+Checks if upper score bonus can be awarded
+@return [Fixnum] 0 if raw_upper < 63
+@return [Fixnum] 35 if raw_upper >= 63
+=end
+	def upper_score_bonus
+		if raw_upper >= 63 then 35
+		else
+			0
+		end
+	end
+=begin
+@return [Fixnum]
+Checks to see if you have all the of the same dice
+=end
+	def yahtzee
+		if dice.values.all? {|x| x == dice.values[0]}
+			@num_yahtzees += 1
+			return sheet[:yahtzee][0] + 50 * 2 ** (@num_yahtzees - 1)
+		else
+			return 0
+		end
+	end
+
+=begin
+	@todo Find a less complex way to create final string
+	@return [String]
+	
+=end
+	def to_s
+		ss = String.new
+		ss += %Q( S C O R E  S H E E T ).center(80, ?=) + "\n\n"
+		(0..(UpperScores.length - 1)).each { |i| ss += print_score_sheet_line(i) }
+		ss += bonus_yahtzee_line
+		ss += "\n\n"
+		ss += "Total Score: #{total}".center(80) + ?\n
+		ss += (?= * 80) + ?\n
+		return ss
+	end
+
+	
+	private # Helper methods
+
+	def available (field)
+		@sheet[field][1] == false
+	end
+
+	def score_sheet_line(left_val, right_val)
+		(left_val + "\t\t" + right_val).center(68) + ?\n
+	end
+	alias ssl score_sheet_line
+	
+	def print_score_sheet_line(i);
+		upper, lower = format_score(UpperScores, i), format_score(LowerScores, i)
+		ssl upper, lower
+	end
+	
+
+	def bonus_yahtzee_line
+		bonus_string, yahtzee_string = justify_score("Bonus", upper_score_bonus.to_s), format_score(LowerScores, LowerScores.length - 1)
+		ssl bonus_string, yahtzee_string
+	end
+	alias byl bonus_yahtzee_line
+=begin
+@return [String] the formatted string
+@param index [Fixnum]
+@param score_region [String, Array<String>]
+Replace underscores with spaces
+=end
+	def format_score(score_region, index)
+		score_label = "#{score_region[index]}".tr(?_, " ")
+		cap_label score_label
+		score_field = @sheet[score_region[index]]
+		return justify_score(score_label, "#{score_field[1]? score_field[0]:?-}")
+	end
+
+	def justify_score(label, score)
+		label.ljust(20) + score.rjust(3)
+	end
+
+=begin
+@param score_label [String]
+@return [String]
+Capitalize each letter of each word only if the score label has two words
+Else only capitalize the first letter of the score label
+=end
+	def cap_label(score_label)
+		if score_label.split.length == 2
+			score_label = score_label.split.map(&:capitalize)*' '
+		else
+			score_label.capitalize!
+		end
+	end
+public
+	alias display to_s
+end

data/lib/scoring.rb

@@ -0,0 +1,145 @@
+require_relative "dice.rb"
+
+module Scoring # methods for calculating score
+
+	UpperScores = :ones, :twos, :threes, :fours, :fives, :sixes	# The fields on the top section of the score sheet
+	
+	LowerScores = :three_of_a_kind, :four_of_a_kind, :full_house, :small_straight, :large_straight, :chance, :yahtzee  # The fields on the bottom section of the score sheet
+
+=begin
+Checks to see if you have 3 of one kind of dice and 2 of another
+@return [Fixnum] 25 if @dice.dice contains 3 of one Fixnum and 2 of another
+@return [Fixnum] 0 if @dice.dice does not contain 3 of one Fixnum and 2 of another
+=end
+	def full_house(dice)
+		f_table = freq dice
+		if (f_table.length == 2 && f_table.has_value?(3)) || f_table.length == 1 then return 25			
+		else; return 0
+		end
+	end
+	
+=begin
+Checks to see if you have 4 of the same dice
+@return [Fixnum]  0 if <= 4 indices have the same value
+@return [Fixnum]  dice.reduce(:+) if >= 4 indices have the same value
+@see (#three_of_a_kind)
+=end
+	def four_of_a_kind(dice)
+		of_a_kind dice, 4
+	end
+
+=begin
+@param d [Array<Fixnum>] the dice to be tested
+@return [Fixnum] the score
+=end
+	def ones(d)
+		single_face d, 1
+	end
+
+	def twos(d)	# @see (#ones)
+		single_face d, 2
+	end
+
+	def threes(d)	# @see (#ones)
+		single_face d, 3
+	end 
+
+	def fours(d)	# @see (#ones)
+		single_face d, 4
+	end
+
+	def fives(d)	# @see (#ones)
+		single_face d, 5
+	end
+
+	def sixes(d)	# @see (#ones)
+		single_face d, 6
+	end
+
+=begin
+@see (#four_of_a_kind)
+Checks to see if you have 3 of the same dice
+@return [Fixnum] dice.reduce(:+) if there is <= 3 of the same value
+@return [Fixnum] 0 if you do not have a three of a kind
+=end
+	def three_of_a_kind(dice)
+		of_a_kind dice, 3
+	end
+
+=begin
+@param dice [Array<Fixnum>] the dice to be evaluated
+@return [Fixnum] the sum of all the dice
+=end
+	def chance(dice)
+		dice.reduce :+
+	end
+
+=begin
+@param dice [Array<Fixnum>] the dice to be tested
+@return [Fixnum] 30 if there are 3 consecutive Fixnums in dice
+@return [Fixnum] 0 if there are not three conscecutive Fixnums in dice
+@see (#large_straight)
+=end
+	def small_straight(dice)
+		straight dice, 4, 30
+	end
+	alias SS small_straight
+	
+=begin
+@param dice [Array<Fixnum>] the dice to be tested
+@return [Fixnum] 40 if there are 4 consecutive Fixnums in dice
+@return [Fixnum] 0 if there are not three conscecutive Fixnums in dice
+@see (#small_straight)
+=end
+	def large_straight(dice)
+		straight dice, 5, 40
+	end
+	alias LS large_straight
+	
+	private # Helper methods for score calculation
+
+		def single_face(dice, value)
+		 	v = dice.select{|number| number == value}.reduce :+
+		 	unless v.nil?
+		 		return v
+		 	else
+		 		return 0
+		 	end
+		end
+
+		def freq(dice)
+			dice.inject(Hash.new(0)) { |h,v| h[v] += 1; h }
+		end
+
+		def modal_frequency(dice)
+			freq(dice).max_by{|k,v| v}[1]
+		end 
+
+		def of_a_kind(dice, limit)
+			if modal_frequency(dice) >= limit
+				dice.reduce :+
+			else
+				0
+			end
+		end
+
+=begin
+@param dice [Fixnum] the dice to be tested
+@param limit [Fixnum] = 4 for small straight
+@param limit [Fixnum] = 5 for large straight
+common code for both small straight (SS) and large straight (LS)
+@param score [Fixnum] is the score to return
+@return [Fixnum] score
+=end
+	def straight(dice, limit, score) 
+		#each_cons is generating every possible value for a straight of length limit
+		(1..6).each_cons(limit).each do |i|
+			# Asking if i is a subset of dice
+			if (i - dice).empty?
+				return score if (i - dice)
+			end
+		end
+		return 0
+	end
+
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: Ruby_Dice
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Zachary Perlmutter
+- Mario Martinez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  This project is a personal project for educational purposes and becoming accustomed to the Ruby programming paradigm.
+  Furthermore, it's to become accustomed to the Git workflow.
+  Contributions are most welcome!
+email:
+- zrp200@gmail.com
+- zenitram.oiram@gmail.com
+executables:
+- Ruby_Dice
+extensions: []
+extra_rdoc_files:
+- LICENSE.md
+- README.md
+files:
+- LICENSE.md
+- README.md
+- bin/Ruby_Dice
+- lib/Ruby_Dice.rb
+- lib/dice.rb
+- lib/player.rb
+- lib/scoresheet.rb
+- lib/scoring.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- terminal
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A Yahtzee clone written in Ruby that runs in the terminal
+test_files: []