liarsdice_cbarcroft 0.0.1

data/bin/liarsdice

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require 'liars_dice.rb'
+
+@game = LiarsDice.new
+puts @game.welcome_player
+
+until @game.over?
+case @game.current_player
+when "Computer"
+@game.computer_move
+when @game.player
+@game.indicate_player_turn
+@game.player_move
+end
+@game.current_state
+@game.determine_winner
+end
+
+puts "You win!" if @game.player_won?
+puts "Computer wins!" if @game.computer_won?

data/lib/features/liars_dice.feature

@@ -0,0 +1,65 @@
+Feature: Liar's Dice Game
+	As a Ruby student I need a final project
+	In order to pass the class
+	I would like to play the computer at Liars Dice
+
+Scenario: Start Game
+	Given I start a new game
+	When I enter my name as Chris
+	Then the computer welcomes me to the game with "Welcome, Chris!"
+		And randomly chooses who goes first
+		And rolls five random dice for each player
+
+Scenario: My Turn
+	Given I have a started a game
+		And it is my turn
+		And the computer knows my name is Chris
+	Then the computer prints "Chris's turn:"
+		And waits for my input of "FACE 2"
+
+Scenario: Computer's Turn
+	Given I have a started a game
+		And it is the computer's turn
+	Then the computer randomly chooses an open position for its move 
+		And the board should have an X on it
+
+Scenario: Making Moves
+	Given I have a started a game
+		And it is my turn
+	When I enter a bet of "FACE 2"
+		And "FACE 2" is a legal bet
+	Then the face bet should now be 2
+		And it is now the computer's turn
+
+Scenario: Making Bad Moves
+	Given I have a started Tic-Tac-Toe game
+		And it is my turn
+		And I am playing X
+	When I enter a position "A1" on the board
+		And "A1" is taken
+	Then computer should ask me for another position "B2"
+		And it is now the computer's turn
+		
+Scenario: Calling a bet successfully
+	Given I have a started a game
+		And it is my turn
+		And the current bet is face 2, count 4
+		And there are three twos
+	When I enter a bet of "OVER"
+		And "OVER" is a legal bet
+	Then the over bet is successful
+		And it is now the computer's turn
+
+Scenario: Winning the Game
+	Given I have a started Tic-Tac-Toe game
+		And I am playing X
+	When there are three X's in a row
+	Then I am declared the winner
+		And the game ends
+
+Scenario: Game is a draw
+	Given I have a started Tic-Tac-Toe game
+		And there are not three symbols in a row
+	When there are no open spaces left on the board
+	Then the game is declared a draw 
+		And the game ends

data/lib/features/step_definitions/liars_dice-steps.rb

@@ -0,0 +1,131 @@
+require 'rspec/mocks/standalone'
+require '../../liars_dice.rb'
+
+Given /^I start a new game$/ do
+  @game = LiarsDice.new
+end
+
+When /^I enter my name as (\w+)$/ do |name|
+  @game.player = name
+end
+
+Then /^the computer welcomes me to the game with "(.*?)"$/ do |arg1|
+  @game.welcome_player.should eq arg1
+end
+
+Then /^randomly chooses who goes first$/ do
+  [@game.player, "Computer"].should include @game.current_player
+end
+
+Then /^rolls five random dice for each player$/ do
+  (@game.dice[:player] + @game.dice[:computer]).length.should eq 10
+end
+
+Given /^I have a started a game$/ do
+  @game = LiarsDice.new(:player)
+  @game.player = "Chris"
+end
+
+Given /^it is my turn$/ do
+  @game.current_player.should eq "Chris"
+end
+
+Given /^the computer knows my name is Chris/ do
+  @game.player.should eq "Chris"
+end
+
+Then /^the computer prints "(.*?)"$/ do |arg1|
+  @game.should_receive(:puts).with(arg1)
+  @game.indicate_player_turn
+end
+
+Then /^waits for my input of "(.*?)"$/ do |arg1|
+  @game.should_receive(:gets).and_return(arg1)
+  @game.get_player_move
+end
+
+Given /^it is the computer's turn$/ do
+  @game = LiarsDice.new(:computer)
+  @game.current_player.should eq "Computer"
+end
+
+Then /^the computer randomly chooses an open position for its move$/ do
+  open_spots = @game.open_spots
+  @com_move = @game.computer_move
+  open_spots.should include(@com_move)
+end
+
+Given /^the computer is playing X$/ do
+  @game.computer_symbol.should eq :X
+end
+
+Then /^the board should have an X on it$/ do
+  @game.current_state.should include 'X'
+end
+
+Then /^the (.*?) bet should now be (.*?)$/ do |arg1, arg2|
+  @game.current_bet[arg1.to_sym].should eq arg2
+end
+
+When /^I enter a bet of "(.*?)"/ do |arg1|
+  @game.should_receive(:get_player_move).and_return(arg1)
+end
+
+When /^"(.*?)" is a legal bet/ do |arg1|
+  @game.validate_player_move(arg1.split(" ")).should eq true
+end
+
+When /^the current bet is face (.*?), count (.*?)/ do |arg1, arg2|
+  @game.current_bet[:face] = arg1
+  @game.current_bet[:count] = arg2
+end
+
+When /^there are three twos/ do
+  @game.dice[:player] = [1,2,3,4,5]
+  @game.dice[:computer] = [1,2,2,3,4]
+end
+
+Then /^it is now the computer's turn$/ do
+  @game.current_player.should eq "Computer"
+end
+
+When /^the over bet is successful$/ do
+  @game.dice_remaining[:computer].should eq 4
+end
+
+Then /^I am declared the winner$/ do
+  @game.determine_winner
+  @game.player_won?.should be_true
+end
+
+Then /^the game ends$/ do
+  @game.over?.should be_true
+end
+
+Given /^there are not three symbols in a row$/ do
+  @game.board = {
+      :A1 => :X, :A2 => :O, :A3 => :X,
+      :B1 => :X, :B2 => :O, :B3 => :X,
+      :C1 => :O, :C2 => :X, :C3 => :O
+    }
+    @game.determine_winner
+end
+
+When /^there are no open spaces left on the board$/ do
+  @game.spots_open?.should be_false
+end
+
+Then /^the game is declared a draw$/ do
+  @game.draw?.should be_true
+end
+
+When /^"(.*?)" is taken$/ do |arg1|
+  @game.board[arg1.to_sym] = :O
+  @taken_spot = arg1.to_sym
+end
+
+Then /^computer should ask me for another position "(.*?)"$/ do |arg1|
+  @game.board[arg1.to_sym] = ' '
+  @game.should_receive(:get_player_move).twice.and_return(@taken_spot, arg1)
+  @game.player_move.should eq arg1.to_sym
+end

data/lib/liars_dice.rb

@@ -0,0 +1,254 @@
+class LiarsDice
+  attr_reader :player_move, :computer_won, :player_won, :over, :current_bet, :waiting_player
+  attr_accessor :current_state, :dice, :dice_remaining
+  
+  COMMANDS = ["FACE", "COUNT", "OVER", "SPOTON"]
+  
+  def initialize( first_turn = false)
+    system("clear")
+    @players = {:player => "Player", :computer => "Computer"}
+    @current_player = first_turn
+    if first_turn == false
+      @current_player = [:computer, :player].sample
+    end
+    @waiting_player = [:computer, :player].select{|player| player != @current_player}[0]
+    @current_bet = {:face => 1, :count => 1}
+    @dice = {:player => [], :computer => []}
+    @dice_remaining = {:player => 5, :computer => 5}
+    @computer_won = false
+    @player_won = false
+    @over = false
+    self.roll_dice
+        self.current_state
+  end
+  
+  def current_player
+    @players[@current_player]
+  end
+  
+  def player=(str)
+    @players[:player] = str
+  end
+  
+  def player
+    @players[:player]
+  end
+  
+  def welcome_player
+    "Welcome, #{@players[:player]}!"
+  end
+  
+  def indicate_player_turn
+    puts "#{@players[@current_player]}'s turn:"
+  end
+  
+  def switch_turns
+    temp = @current_player
+    @current_player = @waiting_player
+    @waiting_player = temp
+  end
+  
+  def get_player_move
+    gets.chomp
+  end
+  
+  def player_move
+    move = self.get_player_move.split(" ")
+    until (self.validate_player_move(move))
+      move = self.get_player_move.split(" ")
+    end
+    
+    case move[0].upcase
+    when "FACE"
+      puts "You have raised the face value to #{move[1]}"
+      @current_bet[:face] = move[1]
+    when "COUNT"
+      puts "You have raised the count to #{move[1]}"
+      @current_bet[:count] = move[1]
+    when "SPOTON"
+      puts "You think the bet is spot on."
+      self.check_spoton
+    when "OVER"
+      puts "You think the computer's bet is too high."
+      self.check_over
+    end
+    self.switch_turns
+  end
+  
+  def computer_move
+    puts "Computer's Turn:"
+    sleep(1)
+    move = self.smart_select.split(" ")
+    
+    case move[0]
+    when "FACE"
+      puts "Computer has raised the face value to #{move[1]}"
+      @current_bet[:face] = move[1]
+    when "COUNT"
+      puts "Computer has raised the count to #{move[1]}"
+      @current_bet[:count] = move[1]
+    when "SPOTON"
+      puts "Computer thinks the bet is spot on."
+      self.check_spoton
+    when "OVER"
+      puts "Computer challenges your bet."
+      self.check_over
+    end
+    self.switch_turns
+  end
+  
+  def smart_select
+    comp_dice = self.get_dice_total
+    if comp_dice[@current_bet[:face].to_i] == @current_bet[:count] then #if computer has the current bet showing in its own dice
+      if @dice_remaining[:player] <= 2 then #and the player has two or less dice of their own
+        return "SPOTON"
+      else
+        return "COUNT #{@current_bet[:count].to_i + 1}" #increment count by one
+      end
+    elsif (comp_dice[@current_bet[:face].to_i]).to_i < @current_bet[:count].to_i then #if computer has less dice of the current face than the bet
+        if (@current_bet[:count].to_i - comp_dice[@current_bet[:face].to_i].to_i) >= 2 then
+          return "OVER"
+        else
+          return "COUNT #{@current_bet[:count].to_i + 1}"
+        end
+    elsif comp_dice[@current_bet[:face].to_i].to_i > @current_bet[:count].to_i then #if computer has more dice of the current face than the bet
+        if (comp_dice[@current_bet[:face].to_i].to_i - @current_bet[:count].to_i) >= 2 then
+          return "COUNT #{@current_bet[:count].to_i + 2}"
+        else
+          return "COUNT #{@current_bet[:count].to_i + 1}"
+        end
+    else
+      return "OVER" #default bet, but this should never happen
+    end
+  end
+  
+  def validate_player_move(move)
+    valid = true
+    if !COMMANDS.include? move[0].upcase
+      puts "Unrecognized command #{move[0].upcase}"
+      valid = false
+    end
+    if move[0].upcase == "FACE" then
+      if move[1] == nil || move[1].to_i < 1 || move[1].to_i > 6 then
+        puts "Invalid value(#{move[1]}) for FACE"
+        valid = false
+      elsif !(move[1].to_i > @current_bet[:face].to_i)
+        puts "Face bet must be higher than the current bet: #{@current_bet[:face]}"
+        valid = false
+      end
+    end
+    if move[0].upcase == "COUNT" then
+      if move[1].to_i == nil || move[1].to_i < 1 || move[1].to_i > 10 then
+        puts "Invalid value(#{move[1]}) for FACE"
+        valid = false
+      elsif !(move[1].to_i > @current_bet[:count].to_i)
+        puts "Count bet must be higher than the current bet: #{@current_bet[:count]}"
+        valid = false
+      end
+    end
+    valid
+  end
+  
+  def roll_dice
+    @players.each do |player, name|
+      @dice[player] = []
+      @dice[player] = @dice_remaining[player].times.map{ rand(1..6) } 
+    end
+  end
+  
+  def check_spoton
+    puts self.print_dice(true)
+    totals = get_dice_totals
+    if totals[@current_bet[:face].to_i] == @current_bet[:count]
+      puts "#{@players[@current_player]} is correct! #{@players[@waiting_player]} loses one die!"
+      @dice_remaining[@waiting_player] -= 1
+    else
+      puts "#{@players[@current_player]} is wrong, and loses one die! "
+      @dice_remaining[@current_player] -= 1
+    end
+    
+    self.reset
+  end
+  
+  def check_over
+    puts self.print_dice(true)
+    totals = get_dice_totals
+    if totals[@current_bet[:face].to_i].to_i < @current_bet[:count].to_i
+      puts "#{@players[@current_player]} is correct! #{@players[@waiting_player]} loses one die!"
+      @dice_remaining[@waiting_player] -= 1
+    else
+      puts "#{@players[@current_player]} is wrong, and loses one die! "
+      @dice_remaining[@current_player] -= 1
+    end
+    
+    self.reset
+  end
+  
+  def reset
+    self.roll_dice
+    @current_bet[:face] = 1
+    @current_bet[:count] = 1
+  end
+  
+  def get_dice_totals
+    totals = {1 => 0, 2 => 0, 3 => 0, 4 => 0, 5 => 0, 6 => 0} 
+    (@dice[:player] + @dice[:computer]).flatten.each do |die|
+      totals[die] += 1
+    end
+    totals
+  end
+  
+  def get_dice_total
+    totals = {1 => 0, 2 => 0, 3 => 0, 4 => 0, 5 => 0, 6 => 0} 
+    @dice[:computer].each do |die|
+      totals[die] += 1
+    end
+    totals
+  end
+  
+  def current_state
+    puts "Current Bet: Face => #{@current_bet[:face]}   Count => #{@current_bet[:count]}"
+    puts self.print_dice
+  end
+  
+  def print_dice(show_computer = false)
+    @dice[:player].each do |die|
+      print "|#{die}| "
+    end
+    print "   ************   "
+    if show_computer then
+      @dice[:computer].each do |die|
+        print "|#{die}| "
+      end
+    else
+      @dice[:computer].each do |die|
+        print "|X| "
+      end
+    end
+    print "\n"
+  end
+  
+  def dice_remaining?
+    @dice_remaining[:player].to_i > 0 ? true : false
+  end
+  
+  def computer_dice_remaining?
+    @dice_remaining[:computer].to_i > 0 ? true : false
+  end
+  
+  def over?
+    (self.player_won? || self.computer_won?)? true : false
+  end
+  
+  def player_won?
+    self.computer_dice_remaining? ? false : true
+  end
+  
+  def computer_won?
+    self.dice_remaining? ? false : true
+  end
+  
+  def determine_winner
+    @over = self.over?
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: liarsdice_cbarcroft
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Chris Barcroft
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-11 00:00:00.000000000 Z
+dependencies: []
+description: Test your wits against a ... challenged computer
+email: ChrisABarcroft@gmail.com
+executables:
+- liarsdice
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/features/liars_dice.feature
+- lib/liars_dice.rb
+- lib/features/step_definitions/liars_dice-steps.rb
+- bin/liarsdice
+homepage: http://www.google.com
+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.24
+signing_key: 
+specification_version: 3
+summary: Liar's dice game against an amazing computer opponent
+test_files: []