ventiuna 0.0.1

data/lib/ventiuna/hand.rb

@@ -0,0 +1,69 @@
+module Ventiuna
+	class Hand
+		attr_accessor :cards
+
+		def initialize(card=[], *other_cards)
+			@cards = Array(card) + other_cards
+			@soft = false
+			@active = true
+		end
+
+		def << (another_card)
+			self.cards << another_card
+		end
+		alias :hit :<<
+
+		def stand
+			@active = false
+		end
+
+		def split
+			return false unless self.pair?
+			[Ventiuna::Hand.new(self.cards.first), Ventiuna::Hand.new(self.cards.last)]
+		end
+
+		def value
+			sum = 0
+			self.cards.sort.each_with_index do |card, i|
+				# hit low if haven't reached 11 or there are more cards left 
+				hit_low = (sum >= 11) || (i+1 != self.cards.size)
+				@soft = card.ace? && !hit_low
+				sum += card.value(low: hit_low)
+			end
+			sum
+		end
+
+		def active?
+			@active
+		end
+
+		def blackjack?
+			self.value == 21 && self.cards.size == 2
+		end
+
+		def bust?
+			self.value > 21 #&& !self.soft?
+		end
+
+		def pair?
+			self.cards.size == 2 && (self.cards.first.value == self.cards.last.value)
+		end
+
+		def soft?
+			self.value
+			@soft
+		end
+
+		def to_s
+			"#{self.cards.collect{|c| c.to_s}} = #{self.value}"
+		end
+
+		def to_db
+			s = "#{value}"
+			s += "I" if cards.size == 2
+			s += "S" if soft?
+			s += "P" if pair?
+			s
+		end
+	end
+end

data/lib/ventiuna/player.rb

@@ -0,0 +1,127 @@
+module Ventiuna
+	class Player
+		attr_accessor :name, :balance, :hands, :bet, :wins, :loses, :ties
+		attr_reader :decisions
+
+		def initialize(name, strategy: "Learning", balance: 1000000.0)
+			@name = name
+			@strategy = Ventiuna::Strategy.find_or_create_by_name(strategy)
+			@balance = balance
+			@hands = [Ventiuna::Hand.new]
+			@bet = 0
+			@wins = 0
+			@loses = 0
+			@ties = 0
+			@decisions = Hash.new([])
+		end
+
+		def stats
+			"Wins: #{self.wins} (#{self.wins_percent.round}%),    Loses: #{self.loses} (#{self.loses_percent.round}%),    Ties: #{self.ties} (#{self.ties_percent.round}%)"
+		end
+
+		def wins_percent
+			return 0 if total_rounds == 0
+			(self.wins.to_f/self.total_rounds) * 100
+		end
+
+		def loses_percent
+			return 0 if total_rounds == 0
+			(self.loses.to_f/self.total_rounds) * 100
+		end
+
+		def ties_percent
+			return 0 if total_rounds == 0
+			(self.ties.to_f/self.total_rounds) * 100
+		end
+
+		def total_rounds
+			@wins+@loses+@ties
+		end
+
+		def place_bet(min_bet, max_bet)
+			@bet = min_bet
+			@balance -= @bet
+		end
+
+		def active_hand
+			hands.select{ |h| h.active? }.first
+		end
+		alias :hand :active_hand
+
+		def reset_hands
+			@hands = [Ventiuna::Hand.new]
+		end
+		alias :reset_hand :reset_hands
+
+		def decision(dealers_card, strategy: "interactive")
+			define_posible_moves(dealers_card)
+			can_split = hands.size == 1
+			#d = @strategy.decision(dealers_card, hand, can_split)
+			d = nil
+			
+			unless d
+				d = "s"
+				case strategy
+				when "random"
+					d = random_strategy
+				when "interactive"
+					d = interactive
+				end
+			end
+			move = Ventiuna::Move.find_by_strategy_id_and_dealers_card_value_and_hand_and_decision(@strategy.id, dealers_card.value, hand.to_db, d)
+			#puts move.inspect
+			@decisions[hand] = decisions[hand] << move
+			#puts @decisions
+			d
+		end
+
+		def reset_decisions
+			@decisions = Hash.new([])
+		end
+
+		private
+		def posible_moves(dealers_card)
+			moves_list = ["s"]
+			return moves_list if active_hand.bust?
+
+			moves_list.unshift("h") if active_hand.soft? || active_hand.value < 21
+			moves_list.unshift("sp") if active_hand.pair?
+			moves_list.unshift("d") if active_hand.cards.size == 2
+			
+			moves_list
+		end
+
+		def define_posible_moves(dealers_card)
+			posible_moves(dealers_card).each do |m|
+				Ventiuna::Move.find_or_create_by_strategy_id_and_dealers_card_value_and_hand_and_decision(@strategy.id, dealers_card.value, hand.to_db, m).save
+			end
+		end
+
+		def random_strategy
+			return "s" if self.active_hand.bust?
+			return "s" if self.active_hand.value == 21 || self.active_hand.blackjack?
+			return ["s", "h", "d", "sp"].shuffle.pop if self.active_hand.pair?
+			return ["s", "h", "d"].shuffle.pop if self.active_hand.cards.size == 2
+			["s", "h"].shuffle.pop
+		end
+
+		def interactive
+			choice = $stdin.gets.to_s.strip
+
+			case choice
+			when /^hit$|^h$/i
+				"h"
+			when /^stand$|^s$/i
+				"s"
+			when /^double$|^d$/i
+				"d"
+			when /^split$|^sp$/i
+				"sp"
+			else
+				puts "invalid choice!"
+				interactive()
+			end
+				
+		end
+	end
+end

data/lib/ventiuna/shoe.rb

@@ -0,0 +1,19 @@
+module Ventiuna
+	class Shoe < Ventiuna::Deck
+
+		def initialize(deck_count=8)
+			@cards = []
+			suits = @@suits * deck_count
+			suits.each do |suit|
+				@@ranks.each do |rank|
+					@cards << Ventiuna::Card.new(rank: rank, suit: suit)
+				end
+			end
+			@initial_size = @cards.size
+		end
+
+		def needs_shuffling?
+			!self.shuffled? || (self.size.to_f / @initial_size) <= 0.25
+		end
+	end
+end

data/lib/ventiuna/strategies/move.rb

@@ -0,0 +1,32 @@
+module Ventiuna
+	class Move < ActiveRecord::Base
+		belongs_to :strategy
+
+		#validates_presence_of :dealers_card, :cards, :hand_value, :decision
+		validates_uniqueness_of :decision, :scope => [:strategy_id, :dealers_card_value, :hand]
+
+		def score
+			#win_count*2 + tie_count
+			(win + tie + progress) - (lose + bust)
+		end
+
+		def update_counts(outcome)
+			value = 1
+			value = 2 if decision == "d"
+			case outcome
+			when "blackjack", "win"
+				self.win += value
+			when "tie"
+				self.tie += value
+			when "bust"
+				self.lose += value
+			when "lose"
+				self.lose += value
+			when "progress"
+				
+				self.progress += 1
+			end
+			self.save
+		end
+	end
+end

data/lib/ventiuna/strategies/strategy.rb

@@ -0,0 +1,28 @@
+module Ventiuna
+	class Strategy < ActiveRecord::Base
+		has_many :moves
+
+		validates_uniqueness_of :name
+
+		def decision(dealers_card, players_hand, can_split)
+			best_score(dealers_card, players_hand, can_split)
+		end
+
+		private
+		def best_score(dealers_card, players_hand, can_split)
+			r = nil
+			best_move = nil
+			past_moves = self.moves.where(:dealers_card_value => dealers_card.value, :hand => players_hand.to_db)
+			#puts past_moves.inspect
+			#past_decisions = past_moves.collect{ |m| m.decision }
+			#return nil unless past_decisions.include?("h") && past_decisions.include?("s")
+			past_moves.each do |m|
+				best_move = m unless best_move
+				next if m.decision == "sp" && !can_split # can't split here
+				best_move = m if m.score > best_move.score
+			end
+			r = best_move.decision if best_move
+			r
+		end
+	end
+end

data/lib/ventiuna/version.rb

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

data/test/test_card.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+class TestCard < Test::Unit::TestCase
+	def test_init
+		duce_of_clubs = Ventiuna::Card.new(rank: "2", suit: "club")
+		assert_equal("2", duce_of_clubs.rank)
+		assert_equal("club", duce_of_clubs.suit)
+	end
+
+	def test_value
+		duce_of_clubs = Ventiuna::Card.new(rank: "2", suit: "club")
+		assert_equal(2, duce_of_clubs.value)
+
+		king_of_hearts = Ventiuna::Card.new(rank: "K", suit: "heart")
+		assert_equal(10, king_of_hearts.value)
+
+		ace_of_spades = Ventiuna::Card.new(rank: "A", suit: "spade")
+		assert_equal(11, ace_of_spades.value)
+		assert_equal(11, ace_of_spades.value(high: true))
+		assert_equal(1, ace_of_spades.value(low: true))
+	end
+end

data/test/test_dealer.rb

@@ -0,0 +1,153 @@
+require 'test_helper'
+
+class TestDealer < Test::Unit::TestCase
+	def setup
+		@dealer = Ventiuna::Dealer.new("TestDealer")
+
+		@duce = Ventiuna::Card.new(rank: "2", suit: "club")
+		@tres = Ventiuna::Card.new(rank: "3", suit: "diamond")
+		@quatro = Ventiuna::Card.new(rank: "4", suit: "heart")
+		@cinco = Ventiuna::Card.new(rank: "5", suit: "diamond")
+		@seis = Ventiuna::Card.new(rank: "6", suit: "heart")
+
+		@seven_of_diamonds = Ventiuna::Card.new(rank: "7", suit: "diamond")
+		@eight_of_spades = Ventiuna::Card.new(rank: "8", suit: "spade")
+		@eight_of_clubs = Ventiuna::Card.new(rank: "8", suit: "club")
+		@nine_of_spades = Ventiuna::Card.new(rank: "9", suit: "spade")
+		@ten_of_clubs = Ventiuna::Card.new(rank: "10", suit: "club")
+
+		@jack_of_clubs = Ventiuna::Card.new(rank: "J", suit: "club")
+		@king_of_hearts = Ventiuna::Card.new(rank: "K", suit: "heart")
+		@ace_of_diamonds = Ventiuna::Card.new(rank: "A", suit: "diamond")
+		@ace_of_spades = Ventiuna::Card.new(rank: "A", suit: "spade")
+		@ace_of_clubs = Ventiuna::Card.new(rank: "A", suit: "club")
+	end
+
+	def test_hit_up_to_17
+		@dealer.hand << @duce
+		@dealer.hand << @duce
+		assert_equal("h", @dealer.decision)
+		@dealer.reset_hand
+
+		@dealer.hand << @duce
+		@dealer.hand << @tres
+		assert_equal("h", @dealer.decision)
+		@dealer.reset_hand
+
+		@dealer.hand << @duce
+		@dealer.hand << @quatro
+		assert_equal("h", @dealer.decision)
+		@dealer.reset_hand
+
+		@dealer.hand << @duce
+		@dealer.hand << @cinco
+		assert_equal("h", @dealer.decision)
+		@dealer.reset_hand
+
+		@dealer.hand << @duce
+		@dealer.hand << @seis
+		assert_equal("h", @dealer.decision)
+		@dealer.reset_hand
+
+		@dealer.hand << @duce
+		@dealer.hand << @seven_of_diamonds
+		assert_equal("h", @dealer.decision)
+		@dealer.reset_hand
+
+		@dealer.hand << @duce
+		@dealer.hand << @eight_of_clubs
+		assert_equal("h", @dealer.decision)
+		@dealer.reset_hand
+
+		@dealer.hand << @duce
+		@dealer.hand << @nine_of_spades
+		assert_equal("h", @dealer.decision)
+		@dealer.reset_hand
+
+		@dealer.hand << @duce
+		@dealer.hand << @ten_of_clubs
+		assert_equal("h", @dealer.decision)
+		@dealer.reset_hand
+
+		@dealer.hand << @tres
+		@dealer.hand << @ten_of_clubs
+		assert_equal("h", @dealer.decision)
+		@dealer.reset_hand
+
+		@dealer.hand << @quatro
+		@dealer.hand << @ten_of_clubs
+		assert_equal("h", @dealer.decision)
+		@dealer.reset_hand
+
+		@dealer.hand << @cinco
+		@dealer.hand << @ten_of_clubs
+		assert_equal("h", @dealer.decision)
+		@dealer.reset_hand
+
+		@dealer.hand << @seis
+		@dealer.hand << @ten_of_clubs
+		assert_equal("h", @dealer.decision)
+		@dealer.reset_hand
+
+		@dealer.hand << @duce
+		assert_equal("h", @dealer.decision)
+		@dealer.hand << @tres
+		assert_equal("h", @dealer.decision)
+		@dealer.hand << @quatro
+		assert_equal("h", @dealer.decision)
+		@dealer.hand << @cinco
+		assert_equal("h", @dealer.decision)
+		@dealer.hand << @ace_of_spades
+		assert_equal("h", @dealer.decision)
+		@dealer.hand << @ace_of_diamonds
+		assert_equal("h", @dealer.decision)
+		@dealer.hand << @ace_of_clubs
+		assert_equal("s", @dealer.decision)
+		@dealer.reset_hand
+	end
+
+	def hit_on_soft_17
+		@dealer.hand << @ace_of_diamonds
+		@dealer.hand << @seis
+		assert_equal("h", @dealer.decision)
+		@dealer.reset_hand
+
+		@dealer.hand << @ace_of_diamonds
+		@dealer.hand << @duce
+		@dealer.hand << @quatro
+		assert_equal("h", @dealer.decision)
+		@dealer.reset_hand		
+	end
+
+	def stand_on_17_and_up
+		#17
+		@dealer.hand << @nine_of_spades
+		@dealer.hand << @eight_of_clubs
+		assert_equal("s", @dealer.decision)
+		@dealer.reset_hand
+
+		#18
+		@dealer.hand << @ace_of_diamonds
+		@dealer.hand << @seven_of_diamonds
+		assert_equal("s", @dealer.decision)
+		@dealer.reset_hand
+
+		#19
+		@dealer.hand << @ace_of_diamonds
+		@dealer.hand << @eight_of_clubs
+		assert_equal("s", @dealer.decision)
+		@dealer.reset_hand
+
+		#20
+		@dealer.hand << @ace_of_diamonds
+		@dealer.hand << @nine_of_spades
+		assert_equal("s", @dealer.decision)
+		@dealer.reset_hand
+
+		#21
+		@dealer.hand << @ace_of_diamonds
+		@dealer.hand << @jack_of_clubs
+		assert_equal("s", @dealer.decision)
+		@dealer.reset_hand
+	end
+end