simpleblackjack 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 48e580c4ae782c8d7626d4cd36d9a965f4a1c217
+  data.tar.gz: dba6046bbd683ef8c5c06a1ed48ff2abb83744e4
+SHA512:
+  metadata.gz: f3edd852c1e1e13abc2c59f8c92e1922633e7a5d9255b9882469b688b4012f3500454429a9905655c97a6c36d5534b15a169b1dcc54413130579b5cc8e3d73d9
+  data.tar.gz: 704e55b6a7fd00f27e102e0d2276caf84b20a899a09647c68c6678b83d9f3cb74e41d352d016423df7a54008f24d09805599d527d42b641db76a2ab3943a137e

data/bin/blackJack

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../'))
+
+require 'rubygems'
+require 'colorize'
+require 'lib/blackjack'
+
+@game = BlackJackGame::Game.new

data/bin/blackjack

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../'))
+
+require 'rubygems'
+require 'colorize'
+require 'lib/blackjack'
+
+@game = BlackJackGame::Game.new

data/lib/blackjack.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+require 'lib/blackjack/version'
+require 'lib/blackjack/cards/deck'
+require 'lib/blackjack/cards/card'
+require 'lib/blackjack/cards/card_types'
+require 'lib/blackjack/players/player'
+require 'lib/blackjack/players/blackjack_player'
+require 'lib/blackjack/players/dealer'
+require 'lib/blackjack/game/game_logic'
+require 'lib/blackjack/game/board'
+
+
+module BlackJackGame
+
+  class Game
+    attr_accessor :players
+    attr_accessor :game_logic
+
+    # Create a new player list and Game Deck
+    def initialize
+      @players = []
+      @players.push(Dealer.new("Mr. Dealer"))
+      @players.push(BlackJackPlayer.new("Human"))
+      @game_logic = GameLogic.new(@players)
+      start_game
+    end
+
+    # The Game
+    def start_game
+      @game_logic.game_round
+
+      puts 'Thanks for playing!'
+    end
+
+  end
+
+end

data/lib/blackjack/cards/card.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+require 'colorize'
+
+class Card
+# Container for a game card and helper methods.
+  attr_accessor :type
+  attr_accessor :suit
+
+  # card_suit: shape of card:
+  # card_type: numerical value
+  def initialize(card_suit, card_type)
+    @suit = card_suit[0]
+    @type = card_type[0]
+  end
+
+  # Returns the printed notation of a card
+  # i.e. 2 of diamonds: 2♦
+  def to_s
+    return "#{FrenchDeck.card_face(@type)}#{FrenchDeck::SUIT[@suit]}"
+  end
+
+  # Easy accesor to the value of the card
+  def value
+    return FrenchDeck::TYPE[@type]
+  end
+
+  # Helper to return the text representation of the card in the respective color
+  def print
+    case @suit
+    when :heart, :diamond
+      text = "[#{to_s}]".red.on_white
+    else
+      text = "[#{to_s}]".black.on_white
+    end
+  end
+
+end

data/lib/blackjack/cards/card_types.rb

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+class FrenchDeck
+# Representation of a 52 poker/blackjack card deck.
+
+  # Numeric Type
+  TYPE = {
+    :ace    => 1,
+    :two    => 2,
+    :three  => 3,
+    :four   => 4,
+    :five   => 5,
+    :six    => 6,
+    :seven  => 7,
+    :eight  => 8,
+    :nine   => 9,
+    :ten    => 10,
+    :jack   => 11,
+    :queen  => 12,
+    :king   => 13
+  }.freeze
+
+  # Figure
+  SUIT = {
+    :spade   => "♠",
+    :heart   => "♥",
+    :diamond => "♦",
+    :clove   => "♣"
+  }.freeze
+
+  # Returns the value as it would appear visually on a french deck card
+  # i.e: J or a Jack card.
+  def self.card_face(card_type)
+    case TYPE[card_type]
+    when 2..10
+      TYPE[card_type]
+    when 1
+      "A"
+    when 11
+      "J"
+    when 12
+      "Q"
+    when 13
+      "K"
+    end
+  end
+
+end

data/lib/blackjack/cards/deck.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+class Deck
+# Represents a game deck containing 52 cards.
+# plus helper methods to handle the deck.
+
+  # Creates a new ordered deck. 52 card deck of cards. 1 per suite
+  def self.build_deck
+    deck = []
+    FrenchDeck::SUIT.each do |suit|
+      FrenchDeck::TYPE.each do |type|
+        deck.push( Card.new(suit, type))
+      end
+    end
+    deck
+  end
+
+  # Returns a copy of a random shuffled deck.
+  def self.shuffle(deck)
+    deck.shuffle(Time.now.to_i)
+  end
+end

data/lib/blackjack/game/board.rb

@@ -0,0 +1,140 @@
+# encoding: UTF-8
+class Board
+# Graphic helper methods to display the game board
+
+
+  ####################################################################
+  # Interactive methods
+  ####################################################################
+
+
+  # Drawing routine.
+  # Receives a game state, and draws the board.
+  def self.re_draw(players, action_list = nil, winners = false, game_stats = nil)
+    clear_screen
+    print_header
+    print_separator
+
+    players.each do |p|
+      print_player(p)
+    end
+
+    print_separator
+
+    print_winner_list(winners) if winners
+
+    ask_action(action_list) if action_list
+  end
+
+   # Displays a list of actions to the user, and returns the user's selected action
+  # as a char, being the first letter of the action typed by the user.
+  def self.ask_action(action_list = nil)
+    if action_list
+      action_bar = "Action? (Type key followed by enter)\t".blue
+      action_list.each do |action|
+        action_bar += " - [#{action[0]}]".green + action[1..-1]
+      end
+
+      puts action_bar
+
+      output = STDIN.gets
+
+      return output.capitalize[0]
+    end
+
+    return nil
+  end
+
+
+  ####################################################################
+  # Screen printing
+  ####################################################################
+
+
+  # Prints a player's data and current card deck.
+  def self.print_player(player)
+    hidding     = false
+    player_deck = ""
+
+    player.cards_in_hand.keys.each do |card|
+      if player.cards_in_hand[card] #hidden
+        player_deck += "[░░]".black.on_white
+        hidding = true
+      else
+        player_deck += card.print
+      end
+    end
+
+    puts print_avatar(player)
+    puts " Card Total: #{player.hand_value}".cyan unless hidding
+    puts "\t\t #{player_deck} \n\n"
+
+    print_board_logo if player.kind == :dealer
+  end
+
+  # Helper to print percent of many games a player won
+  def self.print_win_ratio_in_percent(player)
+    "\t\t=> Percent of Games Won: #{player.win_ratio_in_percent}%".green
+  end
+
+  # Prints a colored line
+  def self.print_separator
+    separator = "=-_-=" * 15
+    puts separator.yellow + "\n"
+  end
+
+  # Pretty prints the winner list
+  def self.print_winner_list(winners)
+    puts " **!!!! #{winners.join(' and ')} wins this round!".magenta
+  end
+
+  # clears the display to ready it for a redraw.
+  # this works on linux/osx only
+  def self.clear_screen
+    system('clear')
+  end
+
+
+  ####################################################################
+  # Ascii drawing methods
+  ####################################################################
+
+
+  def self.print_avatar(player)
+    avt = ""
+    case player.kind
+      when :human
+        avt = player_avatar
+      when :dealer
+        avt = dealer_avatar
+    end
+
+    avt + "*".yellow + "  #{player.name} #{print_win_ratio_in_percent(player)} \t\t\t".magenta
+  end
+
+  # Player Character drawing
+  def self.player_avatar
+    return "(゜_゜)".cyan
+  end
+
+  # Dealer Character drawing
+  def self.dealer_avatar
+    return "(ﾉ◕".cyan+"ヮ".blue+"◕)-☆".cyan
+  end
+
+  # Awesomeness generated by http://www.network-science.de/ascii/
+  def self.print_header
+    puts "|    |              |        o          |    ".light_green
+    puts "|---.|    ,---.,---.|__/     .,---.,---.|__/ ".light_green
+    puts "|   ||    ,---||    |  \\     |,---||    |  \\ ".green
+    puts "`---'`---'`---^`---'`   `    |`---^`---'`   `".green
+    puts "                         `---'               ".yellow
+  end
+
+  def self.print_board_logo
+    puts "\n\t\t         /    \\ ".yellow
+    puts "\t\t   ==== | =BJ= | ====".light_green
+    puts "\t\t         \\    /  \n\n".yellow
+  end
+
+end

data/lib/blackjack/game/game_logic.rb

@@ -0,0 +1,159 @@
+# encoding: UTF-8
+class GameLogic
+# Game logic methods
+
+  attr_accessor :player_list
+  attr_accessor :game_number
+  attr_accessor :card_deck
+  attr_accessor :games_before_shuffle
+
+  def initialize(players)
+    @game_number  = 0
+    @player_list  = players
+    @card_deck    = Deck.build_deck
+    @games_before_shuffle = 6
+  end
+
+  # Go Through each player in the game and deal a black jack game.
+  def game_round
+    begin
+      @game_number+=1
+      shuffle_deck!
+      deal_initial_cards(@player_list)
+      do_player_turns
+      update_stats(pick_winner)
+    end while player_wants_to_continue
+  end
+
+  # Ask the player if another round should be dealt
+  def player_wants_to_continue
+    response = Board.re_draw(@player_list,["Quit", "Continue"], pick_winner)
+
+    if response == 'C'
+      return true
+    elsif response == 'Q'
+      return false
+    else
+      player_wants_to_continue
+    end
+  end
+
+  # Iterate each player's turns
+  def do_player_turns
+    last_action = nil
+
+    @player_list.reverse.each do |current_player|
+      if current_player.blackjack_in_hand?
+        current_player.blackjack!
+        next
+      end
+
+      Board.re_draw(@player_list)
+
+      case current_player.kind
+        when :dealer
+          dealer_handler(current_player)
+        when :human
+          while current_player.hand_value < 21 and last_action != :stay
+            last_action = action_handler(current_player)
+          end
+      end
+
+    end
+  end
+
+  # Reshuffle after 6 games OR if remaining stack is less than 15
+  # so the game doesn't run out of cards.
+  def shuffle_deck!
+    if @game_number % @games_before_shuffle == 1 or @card_deck.count < 15
+      @card_deck = Deck.shuffle(Deck.build_deck)
+    end
+  end
+
+  #give 2 start cards to each player
+  def deal_initial_cards(players)
+    players.each do |p|
+
+      p.clear_cards
+
+      if p.kind == :dealer
+        p.add_card(@card_deck.pop, true) #first card from dealer is hidden :)
+        p.add_card(@card_deck.pop, false)
+      else
+        p.add_card(@card_deck.pop, false)
+        p.add_card(@card_deck.pop, false)
+      end
+
+    end
+  end
+
+  # Game action
+  def action_handler(player)
+
+    puts "dealing with #{player.name}"
+    response = Board.re_draw(@player_list,["Hit", "Stay"])
+    case response
+      when 'H'
+        player.add_card(@card_deck.pop, false)
+      when 'S'
+        return :stay
+      else
+        #iterate again
+        action_handler(player)
+    end
+  end
+
+  #deals with the turn of the dealer
+  def dealer_handler(dealer)
+    dealer.reveal_deck
+    Board.re_draw(@player_list)
+
+    while dealer.should_hit?(@player_list)
+      sleep(1)
+      dealer.add_card(@card_deck.pop)
+      Board.re_draw(@player_list)
+    end
+
+  end
+
+  # Logic to picking a winner
+  # Since there is no betting:
+  #   If somebody on the table has blackjack, they are the winners
+  #   Otherwise. whomever gets the top score wins.
+  #   Note: According to casino rules online => Blackjack beats 21
+  def pick_winner
+    max_score    = 0
+    winners      = []
+    blackjackers = []
+
+    @player_list.each do |p|
+      if p.blackjack_in_hand?
+        blackjackers.push(p.name)
+      elsif p.hand_value == max_score
+        winners.push(p.name)
+      elsif p.hand_value > max_score and p.hand_value <= 21
+        winners = []
+        winners.push(p.name)
+        max_score = p.hand_value
+      end
+    end
+
+    #choose the winner!
+    if blackjackers.count > 0
+      return blackjackers
+    else
+      return winners
+    end
+  end
+
+  # update game win/loss ratio stats
+  def update_stats(winners)
+    @player_list.each do |player|
+      player.games_played +=1
+      if winners.include? player.name
+        player.games_won += 1
+      end
+    end
+  end
+
+end

data/lib/blackjack/players/blackjack_player.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+class BlackJackPlayer < Player
+# Represents a game player with the logic for a Black Jack game
+
+  # key value pairs.
+  # k/v pairs for: Card object, Value: boolean representing visibility
+  attr_accessor :cards_in_hand
+
+  # New player with no cards in hand.
+  # Requires name of the player
+  def initialize(name, kind = :human)
+    super(name, kind)
+    clear_cards
+  end
+
+  # Empty the players cards
+  def clear_cards
+    @cards_in_hand = {}
+  end
+
+  # Adds a card to the players deck.
+  # hidden is a flag to display the card as not visible to the players
+  # representing a facing down card.
+  def add_card(card, hidden = false)
+    @cards_in_hand[card] = hidden
+  end
+
+  # Sum of card numeric values
+  # If there's an ace. Will see if flipping its value from 1 to 11 brings the deck closer to 21.
+  # counting 2(or more) aces as 11 won't work here as the deck goes over to 22.
+  def hand_value
+    hand_value = 0
+    has_ace    = false
+
+    @cards_in_hand.keys.each do |c|
+      case c.type
+      when :ace
+        has_ace = true
+        hand_value += 1
+      when :king, :queen, :jack
+        hand_value += 10
+      else
+        hand_value += c.value
+      end
+    end
+
+    if has_ace and (hand_value + 10) <= 21
+      hand_value += 10
+    end
+    hand_value
+  end
+
+  # Checks if the hand contains a blackjack
+  # which is a combo of 2 cards: Ace plus a figure
+  def blackjack_in_hand?
+    blackjack = false
+    if @cards_in_hand.count == 2
+      pair = []
+      pair.push @cards_in_hand.keys.first.type
+      pair.push @cards_in_hand.keys.last.type
+
+      if pair.include?(:ace) and [:jack, :king, :queen].any? { |i| pair.include?(i) }
+        blackjack = true
+      end
+    end
+    blackjack
+  end
+
+  # Makes the whole deck visible.
+  def reveal_deck
+    @cards_in_hand.keys.each do |c|
+      @cards_in_hand[c] = false
+    end
+  end
+
+  # Flip visibility of all cards on black jack
+  def blackjack!
+    @cards_in_hand.keys do |c|
+      @cards_in_hand[c] = false
+    end
+  end
+end

data/lib/blackjack/players/dealer.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+class Dealer < BlackJackPlayer
+# Handles the extra logic of being a Dealer
+
+  # Initializes a new Dealer
+  def initialize(name)
+    super(name, :dealer)
+  end
+
+
+  # Super simple logic.
+  # Dealer keeps hitting until bust or won the game
+  # Hits on hard 17
+  #
+  # Soft 17 contains ace
+  # Hard 17 has no ace
+  def should_hit?(player_against)
+    score_to_beat = 0
+
+    if blackjack_in_hand?
+      blackjack!
+      return false
+    end
+
+    player_against.each do |p|
+      puts p.hand_value
+      if p.kind == :human and p.hand_value > score_to_beat and p.hand_value <= 21
+        score_to_beat = p.hand_value
+      end
+    end
+
+    if hand_value < score_to_beat and hand_value <= 17
+      return true
+    else
+      return false
+    end
+  end
+
+end

data/lib/blackjack/players/player.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+class Player
+# Base abstraction for a game player
+
+  #Kinds of Player
+  KIND =
+  {
+    :dealer => 0,
+    :player => 1
+  }
+
+# Generic player methods.
+  attr_accessor :name
+  attr_accessor :kind
+  attr_accessor :games_won
+  attr_accessor :games_played
+
+  # Creates a new player, initializes it's name.
+  def initialize(name, kind = :player)
+    @name = name
+    @kind = kind
+    @games_won    = 0
+    @games_played = 0
+  end
+
+  # Returns the percent of games won by this player
+  def win_ratio_in_percent
+    win_ratio = @games_won.to_f / @games_played.to_f
+    return win_ratio * 100
+  end
+
+end

data/lib/blackjack/version.rb

@@ -0,0 +1,4 @@
+# encoding: UTF-8
+module BlackJack
+    VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: simpleblackjack
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ivan Marcin
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :runtime
+description: Black Jack card game
+email:
+- ivanmarcin@gmail.com
+executables:
+- blackJack
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/blackjack
+- lib/blackjack.rb
+- lib/blackjack/version.rb
+- lib/blackjack/cards/card.rb
+- lib/blackjack/cards/card_types.rb
+- lib/blackjack/cards/deck.rb
+- lib/blackjack/game/board.rb
+- lib/blackjack/game/game_logic.rb
+- lib/blackjack/players/blackjack_player.rb
+- lib/blackjack/players/dealer.rb
+- lib/blackjack/players/player.rb
+- bin/blackJack
+homepage: https://github.com/ivanmarcin/BJG
+licenses: []
+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: 1.3.5
+requirements: []
+rubyforge_project:
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: Simple Black Jack Game
+test_files: []