yahtzee 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 10f492f5c86781d0d7542d35cdad4406f601e5e6
+  data.tar.gz: 7e3fcb65fb907d5840ec412e94b434f9a381ebfa
+SHA512:
+  metadata.gz: d62578caf18b66adbd3da8d58f5e13c9ff92c818fdc9bdc700078517b069cd6b745ae3641a8eb129282bee5c1424356811d6e077bd47d863e1dc1e2239b97f8b
+  data.tar.gz: 0d9a6dd0a474a3060a6cadafdd63578f36836dab76d8d49bbd4e4c627aca9f2d95b02d2ddb955a186ae435b9a4e89e0490a75f0a40026d90bb5cc48a0922554e

data/lib/yahtzee.rb

@@ -0,0 +1,405 @@
+#require 'grape'
+
+module Yahtzee
+  # class API < Grape::API
+  #   version 'v1.1', using: :header, vendor: :yahtzee
+  # end
+  
+  class Controller
+    def initialize
+      @message = ""
+      
+      @sc = Scorecard.new
+      
+      @turn = Turn.new
+    end
+    
+    def roll
+      @turn = Turn.new
+    end
+    
+    def reroll a
+      @turn.reroll a
+    end
+    
+    def score a 
+      case @sc.score a, @turn.get_dice, @turn.joker?
+      when -1
+        return -1
+      when 0
+        @turn.set_joker true
+        return 0
+      else
+        next_turn
+        return 1
+      end
+    end
+    
+    def next_turn
+      @turn = Turn.new
+    end
+
+    def get_dice
+      return @turn.get_dice
+    end
+
+    def set_dice a
+      @turn.set_dice a
+    end
+    
+    def get_data
+      return @sc.get_cats
+    end
+    
+    def get_potential
+      return sc.calculate_dice @turn.get_dice
+    end    
+  end
+
+  class Turn
+    def initialize
+      @dice     = roll_dice 5
+      
+      @reroll_count = 0
+      @reroll_max   = 2
+      
+      @joker = false
+      @done  = false
+    end
+
+    def roll_dice num_dice
+      a = []
+      
+      num_dice.times do
+        a.push Random.rand(6) + 1
+      end
+      
+      return a
+    end
+
+    def can_reroll?
+      return true if @reroll_count < @reroll_max
+    end
+    
+    def set_preserve pr
+      @preserve = pr
+    end
+    
+    def set_dice a
+      @dice = a
+    end
+
+    def get_preserve
+      return @preserve
+    end
+
+    def get_dice
+      return @dice
+    end
+
+    def get_reroll_count
+      return @reroll_count
+    end
+
+    def joker?
+      return @joker
+    end
+
+    def set_joker value
+      @joker = value
+    end
+
+    def done?
+      return @done
+    end
+
+    def finish
+      @done = true
+    end
+    
+    def reroll preserve # [1,1,1,1,1] preserves all
+      if @reroll_count < @reroll_max
+        a = roll_dice 5
+        5.times do |i|
+          if preserve[i] == 0
+            @dice[i] = a[i]
+          end
+        end
+      end
+      @reroll_count += 1
+    end
+  end
+
+  class Scorecard
+    @@bonus_value          = 35
+    @@full_house_value     = 25
+    @@small_straight_value = 30
+    @@large_straight_value = 40
+    @@yahtzee_value        = 50
+    @@yahtzee_bonus_value  = 100
+
+    def initialize
+      @upper_section = [ :aces, :twos, :threes, :fours, :fives, :sixes ]
+      @lower_section = [ :three_of_a_kind, :four_of_a_kind, :full_house, :small_straight,
+                         :large_straight, :yahtzee, :chance, :yahtzee_bonus ]
+      
+      @categories = { 
+        :aces   => -1, 
+        :twos   => -1,
+        :threes => -1,
+        :fours  => -1,
+        :fives  => -1,
+        :sixes  => -1,
+        :upper_section_bonus => 0,
+
+        :three_of_a_kind => -1,
+        :four_of_a_kind  => -1,
+        :full_house      => -1,
+        :small_straight  => -1,
+        :large_straight  => -1,
+        :yahtzee         => -1,
+        :chance          => -1,
+        :yahtzee_bonus   => 0,
+        
+        :upper_section_subtotal => 0,
+        :upper_section_total    => 0,
+        :lower_section_total    => 0,
+        
+        :grand_total => 0
+      }
+    end
+
+    def calculate_dice dice, joker
+      cats = {
+        :aces   => 0,
+        :twos   => 0,
+        :threes => 0,
+        :fours  => 0,
+        :fives  => 0,
+        :sixes  => 0,
+        :three_of_a_kind => 0,
+        :four_of_a_kind  => 0,
+        :full_house      => 0,
+        :small_straight  => 0,
+        :large_straight  => 0,
+        :yahtzee         => 0,
+        :chance          => 0
+      }
+      
+      # upper section
+      dice.each do |i|
+        case i
+        when 1
+          cats[:aces]   += 1
+        when 2
+          cats[:twos]   += 2
+        when 3
+          cats[:threes] += 3
+        when 4
+          cats[:fours]  += 4
+        when 5
+          cats[:fives]  += 5
+        when 6
+          cats[:sixes]  += 6
+        end
+      end
+
+      # lower section
+      freq = [0,0,0,0,0,0]
+      sum  = 0
+      dice.size.times do |i|
+        sum += dice[i]
+        freq[dice[i]-1] += 1
+      end
+      sfreq = freq.sort.reverse
+      max  = sfreq[0] # number of most frequent dice
+      smax = sfreq[1] # number of second most frequent
+      
+      small = false
+      large = false
+      ssum  = 0
+      sdice = dice.sort.uniq
+      sdice.size.times do |i|
+        ssum += sdice[i]
+      end
+      large = true if sdice.length >= 5 and (ssum == 15 or ssum == 20)
+      small = true if sdice.length >= 4 and (ssum == 10 or ssum == 14 or ssum == 18) or large
+      
+      
+      cats[:three_of_a_kind] = sum if (max >= 3 || joker)
+      cats[:four_of_a_kind]  = sum if (max >= 4 || joker)
+      cats[:full_house]      = @@full_house_value if ((max == 3 and smax == 2) || joker)
+      cats[:small_straight]  = @@small_straight_value if (small || joker)
+      cats[:large_straight]  = @@large_straight_value if (large || joker)
+      cats[:yahtzee]         = @@yahtzee_value if (max >= 5 || joker)
+      cats[:chance]          = sum
+      
+      return cats
+    end
+
+    def score cat, dice, joker
+      pot = calculate_dice dice, joker
+      
+      case cat
+      when (:aces or :twos or :threes or :fours or :fives or :sixes)
+        if @categories[cat] == -1
+          @categories[cat] = pot[cat]
+          calculate_totals
+          return 1
+        end
+      when :yahtzee
+        return -1 if joker
+        case @categories[:yahtzee]
+        when -1
+          @categories[:yahtzee] = pot[:yahtzee]
+          calculate_totals
+          return 1
+        when @@yahtzee_value
+          @categories[:yahtzee_bonus] += @@yahtzee_bonus_value
+        end
+        which = @upper_section[dice[0]-1]
+        if @categories[which] == -1 
+          return score which, dice, joker
+        end
+        return 0
+      else
+        if @categories[cat] == -1
+          @categories[cat] = pot[cat]
+          calculate_totals
+          return 1
+        end
+      end
+      return -1
+    end
+    
+    def add_section sect
+      sum = 0
+
+      @categories.each do |key, value|
+        if (sect.include? key) && value > -1
+          sum += value
+        end
+      end
+
+      return sum
+    end
+
+    def calculate_totals
+      @categories[:upper_section_subtotal] = add_section @upper_section
+      
+      @categories[:upper_section_total] = @categories[:upper_section_subtotal]
+      @categories[:upper_section_bonus] = @@bonus_value if @categories[:upper_section_subtotal] >= 63
+      @categories[:upper_section_total] += @categories[:upper_section_bonus]
+
+      @categories[:lower_section_total] = add_section @lower_section
+
+      @categories[:grand_total] = @categories[:upper_section_total] + @categories[:lower_section_total]
+    end
+
+    def get_cats
+      return @categories
+    end
+  end
+
+  # CLI interface
+
+  class Game
+    def format(score)
+      return "  " if score == -1
+      return "%2d" %[score]
+    end
+
+    def print(score, dice, m1, m2, m3)
+      puts   " ______________________________________ " 
+      printf "|a Aces    [%s] |g 3 of a kind    [%s] | Dice:\n", format(score[:aces]), format(score[:three_of_a_kind])
+      printf "|b Twos    [%s] |h 4 of a kind    [%s] |   a %d\n", format(score[:twos]), format(score[:four_of_a_kind]), dice[0]
+      printf "|c Threes  [%s] |i Full house     [%s] |   b %d\n", format(score[:threes]), format(score[:full_house]), dice[1]
+      printf "|d Fours   [%s] |j Small straight [%s] |   c %d\n", format(score[:fours]), format(score[:small_straight]), dice[2]
+      printf "|e Fives   [%s] |k Large straight [%s] |   d %d\n", format(score[:fives]), format(score[:large_straight]), dice[3]
+      printf "|f Sixes   [%s] |l Yahtzee        [%s] |   e %d\n", format(score[:sixes]), format(score[:yahtzee]), dice[4]
+      printf "|               |  Yahtzee bonus   %3d |\n", score[:yahtzee_bonus]
+      printf "|Subtotal:   %2d |m Chance         [%s] | %s\n", score[:upper_section_subtotal], format(score[:chance]), m1
+      printf "|Bonus:      %2d |                      | %s\n", score[:upper_section_bonus], m2
+      printf "|Total:     %3d |Total:            %3d | %s\n", score[:upper_section_total], score[:lower_section_total], m3
+      printf "|______ Grand Total:%4d ______________|   > ", score[:grand_total]
+      input = STDIN.gets.chomp
+      return input
+    end
+
+
+    def determine_preserve(s)
+      ret = [1,1,1,1,1]
+      s.split("").each do |c|
+        case c
+        when 'a'
+          ret[0] = 0
+        when 'b'
+          ret[1] = 0
+        when 'c'
+          ret[2] = 0
+        when 'd'
+          ret[3] = 0
+        when 'e'
+          ret[4] = 0
+        end
+      end
+      return ret
+    end
+
+    def parse c
+      case c
+      when 'a'
+        cat = :aces
+      when 'b'
+        cat = :twos
+      when 'c'
+        cat = :threes
+      when 'd'
+        cat = :fours
+      when 'e'
+        cat = :fives
+      when 'f'
+        cat = :sixes
+      when 'g'
+        cat = :three_of_a_kind
+      when 'h'
+        cat = :four_of_a_kind
+      when 'i'
+        cat = :full_house
+      when 'j'
+        cat = :small_straight
+      when 'k'
+        cat = :large_straight
+      when 'l'
+        cat = :yahtzee
+      when 'm'
+        cat = :chance
+      else
+        return false
+      end
+      return cat
+    end
+    
+    def start
+      game = Yahtzee::Controller.new
+
+      13.times do |i|
+        print game.get_data, [0,0,0,0,0], "", "", "Press enter to roll"
+        game.roll
+        selection = print game.get_data, game.get_dice, "", "Select which dice you would like to roll again.", "Type the letters of the dice followed by enter: "
+        game.reroll determine_preserve(selection)
+        selection = print game.get_data, game.get_dice, "", "Select which dice you would like to roll again.", "Type the letters of the dice followed by enter: "
+        game.reroll determine_preserve(selection)
+        
+        m1 = ""
+        success = false
+        while !success
+          selection = print game.get_data, game.get_dice, m1, "Select the category for this roll. Type the", "letter of the category followed by enter: "
+          m1 = "Selection invalid"
+          success = game.score(parse(selection.split("")[0]))
+        end
+      end
+      print game.get_data, [0,0,0,0,0], "", "Game complete", ""
+    end
+  end
+end

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: yahtzee
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Christopher Hinstorff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-09 00:00:00.000000000 Z
+dependencies: []
+description: A ruby implementation of the game Yahtzee
+email: christopherhinstorff@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/yahtzee.rb
+homepage: http://chinstorff.com
+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: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: Yahtzee
+test_files: []