truco 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7e1ea4004e96f9ba5e1d5b9df08f35144309e5cc
+  data.tar.gz: d2a2e6fd32a6dab11c998d26a1d0c30a5bb361bb
+SHA512:
+  metadata.gz: 41b1b0ad4497f5c3e022d7bb794422f57c8c1d9f292a9cdfff17e3156881cdb557d9615b0832cd3fcdedb185b761d29136382cddf92affda8008fce412db858a
+  data.tar.gz: a2318c00d823e8cc809da449e9448f5f3ac2ee17ed8811f37655a900d6197c96f314f21bbb2914cfde89fe325919bd8c55279fd3a9bb1733b47555fb360f2d86

data/README.md

@@ -0,0 +1,11 @@
+# Venezuelan Truco in Ruby. #
+
+This is a small game engine that allows you to play Truco Venezuelan style.
+
+Take a look at lib/loader for an example on how to initiate the game. Moreover, we have a good test suite that will give you an idea of how to put everything together.
+
+### TODO: ###
+
+- Logic for envido, truco, etc. AKA apostar between moves. See /lib/truco.rb and spec/truco.rb
+
+- validations: When asking a user for input, we must validate he chooses a correct card.

data/lib/card.rb

@@ -0,0 +1,111 @@
+class Symbol
+  def to_value
+    return card_values[self] if card_values[self]
+    self.to_s.to_i
+  end
+
+  def card_values
+    {
+      # SUITS
+      :"E" => 100,
+      :"P" => 90,
+      :"O" => 80,
+      :"C" => 70,
+      # VALUES
+      :"3" => 30,
+      :"1" => 50,
+      :"2" => 21,
+
+      # Special Cases
+      :"7E" => 45,
+      :"7O" => 40,
+      :"1C" => 20,
+      :"1O" => 20
+    }
+  end
+end
+
+class Card
+
+  include Comparable
+
+  VALID_SUITS= [:"E", :"P", :"O", :"C"]
+
+  VALID_VALUES= [:"1", :"2", :"3", :"4", :"5", :"6", :"7",
+                 :"10", :"11", :"12"]
+
+  def initialize(suit, value)
+    raise "Invalid Card" unless VALID_SUITS.include?(suit)
+    @suit = suit
+    @value = value
+  end
+
+  attr_accessor :suit, :value
+
+  def to_s
+    self.suit.to_s + " "  +  self.value.to_s
+  end
+
+  def <=>(card)
+    @value = :"7E" if is_7_e?
+    card.value = :"7E" if card.is_7_e?
+
+
+    @value = :"7O" if is_7_o?
+    card.value = :"7O" if card.is_7_o?
+
+
+    @value = :"1C" if is_1_c?
+    card.value = :"1C" if card.is_1_c?
+
+    @value = :"1O" if is_1_o?
+    card.value = :"1O" if card.is_1_o?
+
+    if value == card.value
+      if suit.to_value > card.suit.to_value
+        return 1
+      else 
+        return -1
+      end
+    end
+    if value.to_value > card.value.to_value
+      return 1
+    else
+      return -1
+    end
+  end
+
+
+  def is_7_e?
+    value == :"7" && suit == :"E"
+  end
+
+  def is_7_o?
+    value == :"7" && suit == :"O"
+  end
+
+  def is_1_c?
+    (value == :"1" && suit == :"C") or (value == :"1C")
+  end
+
+  def is_1_o?
+    (value == :"1" && suit == :"O") or (value == :"1O")
+  end
+
+
+
+  private 
+
+  def self.valid_suits
+    VALID_SUITS
+  end
+
+  def self.valid_values
+    VALID_VALUES
+  end
+
+end
+
+class TexasHoldem ; end
+
+

data/lib/dealer.rb

@@ -0,0 +1,34 @@
+class Dealer
+
+  attr_accessor :deck, :hand
+
+  def initialize 
+    @deck = Deck.new
+    @hand = Hand.new
+  end
+
+  def deal_to_player(player)
+    player.cards << @deck.cards.pop
+  end
+
+  def flop
+    3.times{ |n| deal }
+  end
+
+  def initial_truco
+    3.times { |n| player.cards << @deck.cards.pop  }
+  end
+
+  def hand
+    @hand
+  end
+
+
+  def deal
+    @hand.cards << @deck.cards.pop
+  end
+
+  alias :river :deal ; alias  :turn :deal
+end
+
+

data/lib/deck.rb

@@ -0,0 +1,21 @@
+class Deck
+
+  def initialize
+    @valid_suits = Card.valid_suits
+    @valid_values = Card.valid_values
+    @stack = Array.new
+
+    @valid_suits.each do |suit|
+      @valid_values.each{|value | @stack << Card.new(suit, value)}
+    end
+
+    self.shuffle
+  end
+
+  def shuffle
+    @stack.shuffle!
+  end
+
+  def cards ; @stack ; end
+
+end

data/lib/fixnum.rb

@@ -0,0 +1,7 @@
+class Fixnum
+  def to_sym
+    to_s.to_sym
+  end
+end
+
+

data/lib/hand.rb

@@ -0,0 +1,18 @@
+class  Hand
+  def initialize
+    @cards = Array.new
+  end
+  def cards
+    #raise unless self.cards.size > 5
+    @cards
+  end
+
+  def to_s
+    @cards.each do |card|
+      puts card.suit.to_s + " " + card.value.to_s
+    end
+    ''
+  end
+end
+
+

data/lib/judge.rb

@@ -0,0 +1,52 @@
+class Judge
+  # For Truco:
+  # 4,5,6,7P, 7C,10,11,12 
+  # 2,3,1
+  # 7O, 7E
+  # 1B, 1E
+  # perica
+  # perico
+
+  # Pintas
+  # C,O,P,E 
+  
+  attr_reader :cards
+  attr_accessor :vira
+
+  def initialize(cards)
+    @cards = cards
+  end
+
+  def winner
+    return perico if perico
+    return perica if perica
+    cards.sort[-1]
+  end
+
+  def suit_rank
+    [
+      :"E",
+      :"P",
+      :"O",
+      :"C"
+    ]
+  end
+
+  private
+
+  def perica
+    return nil unless @vira
+    @cards.clone.keep_if do |card|
+      ((card.value == :"10") && (card.suit == @vira.suit)) or ((card.value == :"12") && (card.suit == @vira.suit) && (@vira.value == :"10"))
+
+    end[0]
+  end
+
+  def perico
+    return nil unless @vira
+    @cards.clone.keep_if do |card|
+      ((card.value == :"11") && card.suit == @vira.suit) or ((card.value == :"12") && (card.suit == @vira.suit) && (@vira.value == :"11"))
+    end[0]
+  end
+
+end

data/lib/loader.rb

@@ -0,0 +1,22 @@
+require './lib/card'
+require './lib/dealer'
+require './lib/fixnum'
+require './lib/hand'
+require './lib/judge'
+require './lib/player'
+require './lib/truco'
+require './lib/deck'
+
+def build_game
+  @player1 = Player.new "Ivan"
+  @player2 = Player.new "Bellatrix"
+
+  @game = Truco.new [@player1, @player2]
+  @game.deal_to_players
+  #@game.to_s
+  @game.play
+
+  puts "EL GANADOR:"
+  puts @game.winner.nickname
+  nil
+end

data/lib/player.rb

@@ -0,0 +1,53 @@
+class Player
+  attr_reader :cards
+  attr_accessor :nickname
+
+  def initialize(nickname=nil)
+    @cards = Array.new
+    @nickname = nickname
+  end
+
+  def cards
+    @cards
+  end
+
+  def play(n)
+    card = posible_moves[n]
+    cards.reject!{ |c| c == card }
+    card
+  end
+
+  def posible_moves
+    h = Hash.new
+    cards.count.times do |n|
+      h[n + 1] = cards[n]
+    end
+    h
+  end
+
+  def display_posible_moves
+    posible_moves.each_pair do |k,v|
+      puts "#{k} | #{v.to_s}"
+    end
+    nil
+  end
+
+  def display_cards
+    cards.each do |card|
+      puts card.suit.to_s + " " + card.value.to_s
+    end
+    nil
+  end
+
+  def delete_card(card)
+    cards.delete_if { |x| x == card }
+  end
+end
+
+class Vira < Player 
+
+  def card
+    cards[0]
+  end
+  
+end

data/lib/truco.rb

@@ -0,0 +1,178 @@
+class Game
+  def initialize
+    @dealer = Dealer.new
+    @players = Array.new
+  end
+
+  def dealer
+    @dealer
+  end
+
+  def players
+    @players
+  end
+
+  def hand
+    @dealer.hand
+  end
+
+  def deal_to_players
+    deal_to_everybody
+  end
+
+  def deal_to_everybody
+    @players.each do |player|
+      @dealer.deal_to_player(player)
+    end
+  end
+
+  def to_s
+   @players.each do |player|
+      puts "#" * 50
+      puts "Player: " + player.object_id.to_s
+      player.display_cards
+      puts "#" * 50
+   end
+  end
+
+  attr_accessor :player_turn
+
+  def ask_player_for_card
+    puts "Waiting for turn of #{@player_turn.object_id.to_s}"
+    @player_turn.display_cards
+    card = gets.chomp
+    puts card.inspect
+  end
+
+end
+
+class Truco < Game
+
+  attr_reader :first_hand, :second_hand, :third_hand, :dealer, :players, :vira
+
+  def initialize(players)
+    @players = players
+    @dealer = Dealer.new
+    @vira = Vira.new
+    @dealer.deal_to_player(vira)
+    @first_hand = Hash.new
+    @second_hand = Hash.new
+    @third_hand = Hash.new
+  end
+
+  def deal_to_players
+    3.times { players.each { |p| dealer.deal_to_player p } }
+  end
+
+  def play_first_hand(player, card)
+    player.delete_card(card)
+    @first_hand[player] = card
+  end
+
+  def play_second_hand(player, card)
+    player.delete_card(card)
+    @second_hand[player] = card
+  end
+
+  def play_third_hand(player, card)
+    player.delete_card(card)
+    @third_hand[player] = card
+  end
+
+  def first_hand_winner
+    @first_hand_winner ||= winner_of_hand(@first_hand)
+  end
+
+  def second_hand_winner
+    @second_hand_winner ||= winner_of_hand(@second_hand)
+  end
+
+  def third_hand_winner
+    @third_hand_winner ||= winner_of_hand(@third_hand)
+  end
+
+  def winner_of_hand(hand)
+    cards = @players.map{|p| hand[p] }
+    judge = Judge.new(cards)
+    judge.vira = vira.card
+    winning_card = judge.winner
+    (winning_card == hand[@players[0]]) ? @players[0] : @players[1]
+  end
+
+  def winner
+    player_won_first_two_hands? ? first_hand_winner : player_that_won_most_matches
+  end
+
+  # TODO: Logic for: Envido, truco, etc. AKA Apostar.
+  
+  def play
+    # playing the first hand
+    players.each { |player| ask_for_user_input(player, "play_first_hand") }
+    self.to_s
+    puts " the winner of the first hand #{first_hand_winner.nickname}"
+
+    #playing the second hand
+    ask_for_user_input(first_hand_winner, "play_second_hand")
+    ask_for_user_input(other_player(first_hand_winner), "play_second_hand")
+
+    self.to_s
+    puts " the winner of the second hand #{second_hand_winner.nickname}"
+    return if player_won_first_two_hands?
+
+    #playing the third hand
+    ask_for_user_input(second_hand_winner, "play_third_hand")
+    ask_for_user_input(other_player(second_hand_winner), "play_third_hand")
+
+    self.to_s
+  end
+
+  def to_s
+    puts "First Hand:"
+    display_hand(@first_hand)
+    puts "Second Hand:"
+    display_hand(@second_hand)
+    puts "Third Hand:"
+    display_hand(@third_hand)
+  end
+
+  def first_turn_for_second_hand
+    first_hand_winner
+  end
+
+  def first_turn_for_third_hand
+    second_hand_winner
+  end
+
+  def other_player(p)
+    players.clone.reject{ |player| player == p}[0]
+  end
+
+  private
+
+  def display_hand(hand)
+    return if hand == {}
+    puts "#" * 20
+    hand.each do |k,v|
+      puts "#{k.nickname}: #{v.to_s}"
+    end
+  end
+
+  def player_that_won_most_matches
+    [ first_hand_winner, second_hand_winner, third_hand_winner].group_by { |d| d }.keys.first
+  end
+
+  def player_won_first_two_hands?
+    first_hand_winner == second_hand_winner
+  end
+
+  def ask_for_user_input(player, method)
+    puts "La vira: #{vira.card.to_s}"
+    puts "What are you going to Play #{player.nickname}?"
+    puts player.display_posible_moves
+    p = gets
+    card = player.play p.to_i
+    self.send(method, player, card)
+    100.times{ puts nil } 
+  end
+
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: truco
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ivan Acosta-Rubio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: A game engine to play truco.
+email:
+- ivan@softwarecriollo.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/card.rb
+- lib/dealer.rb
+- lib/deck.rb
+- lib/fixnum.rb
+- lib/hand.rb
+- lib/judge.rb
+- lib/loader.rb
+- lib/player.rb
+- lib/truco.rb
+homepage: http://www.softwarecriollo.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.2.0
+signing_key: 
+specification_version: 4
+summary: A game engine to play truco.
+test_files: []