Card Game Data Structure

[Trickster]

Card Game Data Structure
Version: 1.0

Introduction
This is mainly a tool for scripters, This small script contains classes that are very useful in making card games (Ex. BlackJack, Poker, etc.). Includes A Deck Class, A Card class, A Hand class, a Sprite class for Cards. Also includes Card graphics.


Screenshots
Look at the script editor after you add this, there's your screenshot


Demo
Pretty much pointless, see my BlackJack demo for an aplication of this.


Script
Yay the families will be overjoyed...

Code:

class Game_Deck
  #--------------------------------------------------------------------------
  # * Constants
  #--------------------------------------------------------------------------
  Suits = %w( spades hearts diamonds clubs )
  Values = 'A','2','3','4','5','6','7','8','9','10','J','Q','K'
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(num_decks = 1)
    # Setup Cards
    @cards = []
    # Setup Deck
    @deck = []
    # Setup Discarded
    @discard = []
    # Setup In Play
    @in_play = []
    # Setup Number of Decks
    @num_decks = num_decks
    # Setup Cards
    setup_cards
    # Shuffle
    shuffle
  end
  #--------------------------------------------------------------------------
  # * Setup Cards
  #--------------------------------------------------------------------------
  def setup_cards
    # Run Through number of decks times
    @num_decks.times do
      # Run Through Each Suit
      Suits.each do |suit|
        # Run Through each value
        Values.each do |number|
          # Setup Card
          card = Game_Card.new(suit, number)
          # Push into cards array
          @deck << card
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Shuffle
  #--------------------------------------------------------------------------
  def shuffle
    # Setup local variable cards
    cards = []
    # Clear Discarded
    @discard.clear
    # Setup Cards to Deck
    @cards = [@deck].flatten!
    # Delete Cards already out
    delete_in_use_cards
    # Run through until cards are empty
    until @cards.empty?
      # Push a Random Card and Delete
      cards << @cards.delete_at(rand(@cards.size))
    end
    # Set Cards to Cards
    @cards = cards
  end
  #--------------------------------------------------------------------------
  # * Draw
  #--------------------------------------------------------------------------
  def draw(number = 1)
    # Return if number is 1
    if number == 1
      # Shuffle if empty?
      shuffle if @cards.empty?
      # Get Card
      card = @cards.shift
      # Add Card to in play
      @in_play << card
      # Return card
      return card
    end
    # Setup Array
    drawn = []
    # Run Through number of times
    number.times do
      # Shuffle if empty?
      shuffle if @cards.empty?
      # Break if cards are still empty (all in play)
      break if @cards.empty?
      # Get Card
      card = @cards.shift
      # Add Card to in play
      @in_play << card
      # Add to Drawn
      drawn << card
    end
    # Return Drawn Cards
    return drawn
  end
  #--------------------------------------------------------------------------
  # * Discard In Play
  #--------------------------------------------------------------------------
  def discard
    # Add all in play cards to discard
    @discard += @in_play
    # Clear in play
    @in_play.clear
  end
  #--------------------------------------------------------------------------
  # * Number
  #--------------------------------------------------------------------------
  def number(*strings)
    # Setup Local Variable
    number = 0
    # Run Through each card
    @cards.each do |card|
      # Run Through Each String Sent to this method
      strings.each do |string|
        # If A Suit
        if Suits.include?(string)
          # Increase By 1 if suits are equal
          number += 1 if card.suit == string
        # If A Value
        elsif Values.include?(string)
          # Increase By 1 if values are equal
          number += 1 if card.value == string
        end
      end
    end
    return number
  end
  #--------------------------------------------------------------------------
  # * Size
  #--------------------------------------------------------------------------
  def size
    return @cards.size
  end
  #--------------------------------------------------------------------------
  # * Delete Cards In Use
  #--------------------------------------------------------------------------
  private
  def delete_in_use_cards
    # Return if empty cards
    return if @in_play.empty?
    # Run Through each in play card and Delete Card from list
    @in_play.each {|card| @cards.delete(card)}
    # Clear In Play
    @in_play.clear
  end
end

class Game_Card
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader :number
  attr_reader :suit
  attr_reader :value
  attr_accessor :flipped
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(suit, value, face10 = false, ace11 = false)
    @suit = suit
    @value = value
    @face10 = face10
    @ace11 = ace11
    @flipped = true
    setup_number
  end
  #--------------------------------------------------------------------------
  # * Ace?
  #--------------------------------------------------------------------------
  def ace?
    return @value == 'A'
  end
  #--------------------------------------------------------------------------
  # * King?
  #--------------------------------------------------------------------------
  def king?
    return @value == 'K'
  end
  #--------------------------------------------------------------------------
  # * Queen?
  #--------------------------------------------------------------------------
  def queen?
    return @value == 'Q'
  end
  #--------------------------------------------------------------------------
  # * Jack?
  #--------------------------------------------------------------------------
  def jack?
    return @value == 'J'
  end
  #--------------------------------------------------------------------------
  # * Face?
  #--------------------------------------------------------------------------
  def face?
    return ['J','Q','K'].include?(@value)
  end
  #--------------------------------------------------------------------------
  # * Ten?
  #--------------------------------------------------------------------------
  def ten?
    return @value == '10' || (self.face? and @face10)
  end
  #--------------------------------------------------------------------------
  # * To String (Returns card's value)
  #--------------------------------------------------------------------------
  def to_s
    return self.value
  end
  #--------------------------------------------------------------------------
  # * Setup Number (Private)
  #--------------------------------------------------------------------------
  private
  def setup_number
    case @value
    when 'A'
      @number = @ace11 ? 11 : 1
    when 'J'
      @number = @face10 ? 10 : 11
    when 'Q'
      @number = @face10 ? 10 : 12
    when 'K'
      @number = @face10 ? 10 : 13
    else
      @number = @value.to_i
    end
  end
end

class Game_CardHand
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    # Setup Cards
    @cards = []
  end
  #--------------------------------------------------------------------------
  # * Each (Runs Through Each Card in Hand)
  #--------------------------------------------------------------------------
  def each
    @cards.each {|card| yield(card)}
  end
  #--------------------------------------------------------------------------
  # * Cards
  #--------------------------------------------------------------------------
  def cards
    return @cards.size
  end
  #--------------------------------------------------------------------------
  # * Draw
  #--------------------------------------------------------------------------
  def draw(*cards)
    @cards.push(*cards)
  end
  #--------------------------------------------------------------------------
  # * Discard
  #--------------------------------------------------------------------------
  def discard
    @cards.clear
  end
  #--------------------------------------------------------------------------
  # * To String (ex. A234K)
  #--------------------------------------------------------------------------
  def to_s
    string = ''
    @cards.each {|card| string += card.to_s}
    return string
  end
end

module RPG
module Cache
  #--------------------------------------------------------------------------
  # * Card
  #--------------------------------------------------------------------------
  def self.card(suit, number)
    style = $game_system.card_style
    self.load_bitmap("Graphics/Cards/#{style}/", "#{suit}_#{number}")
  end
  #--------------------------------------------------------------------------
  # * Card Back
  #--------------------------------------------------------------------------
  def self.card_back(style)
    self.load_bitmap("Graphics/Cards/Backs/", style)
  end
end
end

class Sprite_Card < Sprite
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(card, flipped = true)
    super(nil)
    # Setup Suit and Value
    @suit, @value = card.suit, card.value
    # Setup Flipped Flag
    @flipped = flipped
    # Setup Bitmap
    if @flipped
      # Get Flipped Card
      self.bitmap = RPG::Cache.card(@suit, @value)
    else
      # Get Card Back
      self.bitmap = RPG::Cache.card_back($game_system.card_back_style)
    end
  end
  #--------------------------------------------------------------------------
  # * Flipped
  #--------------------------------------------------------------------------
  def flipped=(bool)
    # Set Flipped Flag
    @flipped = bool
    # Setup Bitmap
    if @flipped
      # Get Flipped Card
      self.bitmap = RPG::Cache.card(@suit, @value)
    else
      # Get Card Back
      self.bitmap = RPG::Cache.card_back($game_system.card_back_style)
    end
  end
end

class Game_System
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :card_style
  attr_accessor :card_back_style
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  alias card_setup_initialize initialize
  def initialize
    # The Usual
    card_setup_initialize
    # Setup Card Style
    @card_style = 'Normal'
    # Setup Card Back Style
    @card_back_style = 'DragonKid'
  end
end

Instructions
The best way to ensure compatibility is to make classes that inherit from these classes like I did in my BlackJack minigame, I tried to include useful methods in these classes and I will give an explanation of what each of them do here

Name: Game_Deck
Description: The Deck class. Holds in play, discarded, and cards not played yet, automatically shuffles if there are no cards left, also handles multiple decks.
Methods:

• initialize(number of decks) (private)
  - Creates a new Game_Deck object automatically called from the new method, the parameter number of decks is the number of decks of cards to use (The Default is 1)
  
• setup_cards
  - Creates all of the Cards, one for each suit and value
  
• shuffle
  - Shuffles the Deck
  
• draw(number of cards)
  - Draws number of cards from the deck automatically shuffles if the deck is empty during this process, the parameter number of cards is the number of cards to draw (The default is 1). If only one card is drawn this method will return that card, else it will return an array.
  - Note: will return as many cards as it can if drawing more than one card (All cards could be in play making it unable to shuffle)
  
• discard
  - Discards All In Play Cards
  
• number(variable amount of strings)
  - Tells how many of cards of suit or value are remaining in the deck. The strings have to match with the constants which is explained further down
  
• size
  - Tells how many cards are remaining in the deck
  
• delete_in_use_cards (private)
  - Deletes all in play cards from deck, used when reshuffling

Constants:

• Suits
  -The suits used, by default there are clubs, hearts, diamonds, and spades.
  - Note: remember create a class that inherits from this one and then change the constant in that class if for any reason you want to change it (note you will have to rename/add graphics if if you do)
  
• Values
  - The values used, by default A-K (Ace, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, and K). No Jokers.
  - see note for Suits.

Properties:

• None

Name: Game_Card
Description: The Card class. Represents a card. It is created and used within the Game_Deck class.
Methods:

• initialize(suit, value, face cards are 10, aces are 11) (private)
  - Creates a new Game_Card object automatically called from the new method, the parameter suit tells the suit of the card, value is the value of the card, face cards are 10 flag telling if face cards (J,Q,K) are worth 10 else their worth is 11,12,and 13 repectively, aces are 11 flag telling if aces are worth 11 instead of 1
  
• ace?
  - returns true if the card is an ace
  
• jack?
  - returns true if the card is a jack
  
• queen?
  - returns true if the card is a queen
  
• king?
  - returns true if the card is a jack
  
• face?
  - returns true if the card is a face card
  
• ten?
  - returns true if the card is worth 10
  
• to_s
  - returns a String Representation of this object (The Cards Value)
  
• setup_number (private)
  - Sets up the cards worth.

Constants:

• None

Properties:

• number (readable)
  
• The Cards Worth. (1-13)
  
• suit (readable)
  
• The Cards Suit.
  
• value (readable)
  
• The Cards Value. (A-K)
  
• flipped (accessible)
  
• The Flipped Flag It is set to true in the initialize method.

Name: Game_CardHand
Description: A Class for a Player's Hand, Holds Game_Card objects.
Methods:

• initialize (private)
  - Creates a new Game_CardHand object automatically called from the new method. Nothing fancy here.
  
• each
  
• Runs through all cards in hand
  
• cards
  
• Returns the number of card in hand
  
• draw(variable amount Game_Card)
  - Adds Cards to Hand
  
• discard
  
• Discards (Clears) All cards from Hand
  
• to_s
  
• returns the string representation of this object, that is the values of all cards in hand

Constants:

• None

Properties:

• None

Name: Sprite_Card
Description: A Sprite Class for Displaying Cards.
Methods:

• initialize(card, flipped flag) (private)
  - Creates a new Sprite_Card object automatically called from the new method. The Parameter card is a Game_Card Object, and the flipped flag tells if the card is displayed face up or face down (The Default is true - face up)
  
• flipped=(boolean)
  - Sets the flipped flag, either send true or false to this method

Constants:

• None[/list[
  
  Properties:
  • None
  
  
  FAQ
  Note: Permission granted by Trickster to post:
  

  And if you post what you have now of my stuff then you don't have the latest versions. I'm too lazy/busy to post stuff.

  As this is his material, it is deletable upon his request. Due to his current absense, no support is available. Please do not PM or eMail him for support.
  
  
  Compatibility
  Should be compatible with anything as long as you follow my note in the instructions section
  
  
  Credits and Thanks
  EiB for providing me with the graphics (see attachment)
  Tana - DragonKid
  
  If I'm missing anything PM me and tell
  
  
  Terms and Conditions
  Hey, I posted this publicly. You can use it. What do you expect? But if you do use it, I do expect you to spell my name correctly in your game. And yes you can use it in commercial games too.