patience 0.1.0 → 0.1.1

data/CHANGELOG.md

@@ -1,6 +1,11 @@
 Patience changelog
 ==================
 
+## v0.1.1 (April 03, 2012)
+
+* Noticeably improved graphics (it's like a whole new game!)
+* Fixed minor bugs
+
 ## v0.1.0 (March 06, 2012)
 
 * Initial release.

data/lib/patience/card.rb

@@ -98,7 +98,8 @@ module Patience
       sprite.collide?(other_card.sprite) and self.not.eql?(other_card)
     end
 
-    def_delegators :@sprite, :pos, :pos=, :x, :y, :to_rect
+    def_delegators :@sprite, :pos, :pos=, :x, :y, :to_rect,
+                   :sprite_width, :sprite_height
     def_delegator  :"@sprite.to_rect", :contain?, :hit?
 
     class DefunctRank < StandardError; end

data/lib/patience/event_handlers/click.rb

@@ -65,7 +65,9 @@ module Patience
       # Adds a card from Stock to Waste, if Stock was clicked.
       def stock
         if stock?
+
           if pile.empty?
+            return if @areas[:waste].cards.size == 1
             pile_background = 'patience/sprites/pile_background.png'
             pile.background = Ray::Sprite.new path_of(pile_background)
             refill_stock
@@ -74,9 +76,15 @@ module Patience
           end
 
           if pile.empty?
-            empty_stock = 'patience/sprites/empty_stock.png'
-            pile.background = Ray::Sprite.new path_of(empty_stock)
+            if @areas[:waste].cards.size == 1
+              fully_empty_stock = 'patience/sprites/fully_empty_stock.png'
+              pile.background = Ray::Sprite.new path_of(fully_empty_stock)
+            else
+              empty_stock = 'patience/sprites/empty_stock.png'
+              pile.background = Ray::Sprite.new path_of(empty_stock)
+            end
           end
+
         end
       end
 

data/lib/patience/event_handlers/drag.rb

@@ -21,7 +21,7 @@ module Patience
       # Changes position of the card's sprite, considering the offset.
       def move(mouse_pos)
         @tail_cards.keys.each_with_index do |card, i|
-          card.pos = mouse_pos + @offset + [0, i*20]
+          card.pos = mouse_pos + @offset + [0, i*19]
         end
       end
 

data/lib/patience/event_handlers/drop.rb

@@ -17,14 +17,14 @@ module Patience
       attr_reader :scenario
 
       def initialize(click, areas)
-        @cards = click.cards
-        @areas = areas
-        @pile = click.pile
+        @cards        = click.cards
+        @areas        = areas
+        @pile         = click.pile
         @card_to_drop = click.card
 
         @card_beneath = find_card_beneath
         @pile_beneath = find_pile_beneath
-        @area = find_area_beneath
+        @area         = find_area_beneath
 
         @scenario = -> {
           if tableau?
@@ -51,21 +51,25 @@ module Patience
         detect_in(@areas, :pile) do |pile|
           # If dropped card is a king or an ace, don't
           # check, whether a pile includes card beneath.
-          pile != @pile and pile.overlaps?(@card_to_drop) and
-          (king_or_ace ? pile.empty? : pile.cards.include?(@card_beneath))
+          pile != @pile && pile.overlaps?(@card_to_drop) &&
+          (if king_or_ace
+             pile.empty? || (@card_beneath && @card_beneath.rank.queen?)
+           else
+             pile.cards.include?(@card_beneath)
+           end)
         end
       end
 
       # Finds a card beneath the dropped card.
       def find_card_beneath
-        all_tail_cards = @areas.values.map do |area|
+        all_tail_cards = @areas.values.flat_map do |area|
           area.piles.map { |pile| pile.cards.last }
-        end.flatten.compact
+        end.compact
 
         # Iterate only over tail cards.
         all_tail_cards.find do |card|
           area = detect_in(@areas, :area) { |area| area.cards.include?(card)}
-          card.face_up? and card.overlaps?(@card_to_drop) and
+          card.face_up? && card.overlaps?(@card_to_drop) &&
           (case area
             when Tableau then tableau_conditions?(card)
             when Foundation then foundation_conditions?(card)
@@ -76,15 +80,15 @@ module Patience
       # Returns true, if card's rank is higher by 1 than the rank of
       # the card which is dropped and the card's suit has different color.
       def tableau_conditions?(card)
-        card.rank.higher_by_one_than?(@card_to_drop.rank) and
+        card.rank.higher_by_one_than?(@card_to_drop.rank) &&
         card.suit.different_color?(@card_to_drop.suit)
       end
 
       # Returns true, if card's rank is lower by 1 than the rank of the
       # card, which is dropped and the card's suit must be the same color.
       def foundation_conditions?(card)
-        @card_to_drop.rank.higher_by_one_than?(card.rank) and
-        card.suit.same_color?(@card_to_drop.suit)
+        @card_to_drop.rank.higher_by_one_than?(card.rank) &&
+        card.suit == @card_to_drop.suit
       end
 
       # Removes card from its pile and adds to the pile beneath.
@@ -100,17 +104,17 @@ module Patience
       # Returns true, if dropped card meets
       # requirements for dropping into Tableau.
       def can_put_in_tableau?
-        (@pile_beneath.empty? and @card_to_drop.rank.king?) or
-        (@card_beneath and @card_to_drop.rank.not.ace? and
-        @pile_beneath.last_card?(@card_beneath) and
+        (@pile_beneath.empty? && @card_to_drop.rank.king?) ||
+        (@card_beneath && @card_to_drop.rank.not.ace? &&
+        @pile_beneath.last_card?(@card_beneath) &&
         tableau_conditions?(@card_beneath))
       end
 
       # Returns true, if dropped card meets
       # requirements for dropping into Foundation.
       def can_put_in_foundation?
-        (@pile_beneath.empty? and @card_to_drop.rank.ace?) or
-        (@card_beneath and foundation_conditions?(@card_beneath))
+        (@pile_beneath.empty? && @card_to_drop.rank.ace?) ||
+        (@card_beneath && foundation_conditions?(@card_beneath))
       end
 
       # Adds dropped card to one of Tableau's piles, if it's
@@ -120,9 +124,9 @@ module Patience
           @cards.keys.each_with_index do |card, i|
             add_to_pile_beneath(card)
             if @pile_beneath.size == 1 # It was empty one line before.
-              card.pos = @pile_beneath.pos + [0, i*20]
+              card.pos = @pile_beneath.pos + [0, i*19]
             else
-              card.pos = @pile_beneath.cards[-2].pos + [0, 20]
+              card.pos = @pile_beneath.cards[-2].pos + [0, 19]
             end
             @pile.cards.last.face_up unless @pile.empty?
           end

data/lib/patience/foundation.rb

@@ -11,7 +11,7 @@ module Patience
 
     def initialize
       super([], 4)
-      self.pos = [361, 23]
+      self.pos = [356, 23]
     end
 
     protected
@@ -20,8 +20,11 @@ module Patience
     # of every pile in this area, starting from the pos argument.
     def pos=(pos)
       x, y, step_x = pos[0], pos[1], 110
+      foundation_bg = path_of('patience/sprites/foundation_bg.png')
+
       piles.each do |pile|
         pile.pos = [x, y]
+        pile.background = Ray::Sprite.new foundation_bg
         x += step_x # Margin between piles along the axis X.
       end
     end

data/lib/patience/pile.rb

@@ -30,7 +30,20 @@ module Patience
 
     # Appends card to the pile considering position of that pile.
     def <<(other_card)
+      bg_w = self.background.sub_rect.w
+      bg_h = self.background.sub_rect.h
+      sprite_w = other_card.sprite_width
+      sprite_h = other_card.sprite_height
+
       other_card.pos = self.pos
+
+      if bg_w > sprite_w && bg_h > sprite_h
+        w = bg_w - sprite_w
+        h = bg_h - sprite_h
+
+        other_card.pos += [w/2, h/2]
+      end
+
       cards << other_card
     end
 

data/lib/patience/rank.rb

@@ -39,13 +39,9 @@ module Patience
         @num <=> other_rank.to_i
       end
 
-      def ace?
-        @num == 1
-      end
-
-      def king?
-        @num == 13
-      end
+      def ace?;   @num == 1;  end
+      def king?;  @num == 13; end
+      def queen?; @num == 12; end
 
       def higher_by_one_than?(other_rank)
         @num - other_rank.to_i == 1

data/lib/patience/scenes/game_scene.rb

@@ -4,7 +4,7 @@ module Patience
   class GameScene < Ray::Scene
 
     def setup
-      @bg_color   = Ray::Color.new(31, 95, 25)
+      @bg_sprite  = Ray::Sprite.new path_of('patience/sprites/table_bg.png')
       @cursor     = Cursor.new
       @deck       = Deck.new
       @deck.cards.shuffle!
@@ -54,7 +54,7 @@ module Patience
     end
 
     def render(win)
-      win.clear @bg_color
+      win.draw @bg_sprite
       @areas.values.to_a.each { |area| area.draw_on(win) }
       # Draw the card, which is being dragged.
       if @cursor.drawable?

data/lib/patience/stock.rb

@@ -13,7 +13,7 @@ module Patience
     def initialize(cards)
       super(cards, 1)
       self.piles.first.cards += @cards.shuffle_off!(24).each(&:face_down)
-      self.pos = [31, 23]
+      self.pos = [31, 27]
     end
 
   end

data/lib/patience/suit.rb

@@ -59,13 +59,13 @@ module Patience
       # Returns true, if the color of suit is
       # the same as the color of other suit.
       def same_color?(other_suit)
-        (black? and other_suit.black?) or (red? and other_suit.red?)
+        (black? && other_suit.black?) || (red? && other_suit.red?)
       end
 
       # Returns true if the color of suit
       # of differs from other suit's color.
       def different_color?(other_suit)
-        (black? and other_suit.red?) or (red? and other_suit.black?)
+        (black? && other_suit.red?) || (red? && other_suit.black?)
       end
 
     end

data/lib/patience/tableau.rb

@@ -17,7 +17,7 @@ module Patience
     def initialize(cards)
       super(cards, 7)
       @piles.each_with_index { |pile, i| pile.cards += @cards.shuffle_off!(i+1) }
-      self.pos = [31, 165]
+      self.pos = [31, 175]
     end
 
     protected
@@ -25,14 +25,16 @@ module Patience
     # Disposes Tableau in the window by specifying coordinates
     # of every pile in this area, starting from the pos argument.
     def pos=(pos)
-      x, y, step_x, step_y = pos[0], pos[1], 110, 26
+      x, y, step_x, step_y = pos[0], pos[1], 110, 10
+
       piles.each { |pile|
         pile.pos = [x, y]
         x += step_x # Margin between piles along the axis X.
         y2 = 0 # Y position of the first card.
+
         pile.cards.each_with_index do |card, i|
           card.sprite.y += y2
-          y2 += step_y # Margin between cards along the axis Y.
+          y2 += step_y # Y axis margin.
           card.face_down unless pile.last_card?(card)
         end
       }

data/lib/patience/version.rb

@@ -1,3 +1,3 @@
 module Patience
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/patience/waste.rb

@@ -11,7 +11,8 @@ module Patience
 
     def initialize
       super([], 1)
-      self.pos = [141, 23]
+      self.pos = [141, 27]
+      self.piles[0].background = Ray::Sprite.new # Emptiness.
     end
 
   end

data/test/patience/event_handlers/test_click.rb

@@ -14,14 +14,14 @@ module Patience
 
     def setup
       @mouse_pos_missclick = Ray::Vector2[0, 0]
-      @mouse_pos_hit = Ray::Vector2[32, 166]
+      @mouse_pos_hit = Ray::Vector2[32, 175]
       @deck = Deck.new
       @areas = { :tableau => Tableau.new(@deck.shuffle_off! 28),
                  :waste => Waste.new,
                  :stock => Stock.new(@deck.shuffle_off! 10) }
       @dummy_click_miss = Dummy.new(@mouse_pos_missclick, @areas)
       @dummy_click_hit  = Dummy.new(@mouse_pos_hit, @areas)
-      @stock_hit = Dummy.new(Ray::Vector2[32, 24], @areas)
+      @stock_hit = Dummy.new(Ray::Vector2[32, 28], @areas)
     end
 
     def fill_attributes_up(click)
@@ -55,21 +55,21 @@ module Patience
 
     test 'A card can be selected by click' do
       # Hit
-      tableau_click = Dummy.new(Ray::Vector2[472, 270], @areas)
+      tableau_click = Dummy.new(Ray::Vector2[472, 176], @areas)
       assert_nil tableau_click.card
       assert_nil tableau_click.cards
       tableau_click.pile = @areas[:tableau].piles[4]
 
       [Card.new(3, 1), Card.new(2, 4)].each do |card|
         @areas[:tableau].piles[4] << card
-        card.pos = @areas[:tableau].piles[4].cards[-2].pos + [0, 20]
+        card.pos = @areas[:tableau].piles[4].cards[-2].pos + [0, 19]
       end
 
       tableau_click.cards = tableau_click.send(:collect_cards).map(&:first)
       assert tableau_click.cards
-      assert_instance_of Card::Rank::Four,  tableau_click.cards[0].rank
+      assert_instance_of Card::Rank::Three, tableau_click.cards[0].rank
       assert_instance_of Card::Rank::Three, tableau_click.cards[1].rank
-      assert_instance_of Card::Rank::Two,   tableau_click.cards[2].rank
+      assert_instance_of Card::Rank::Four,  tableau_click.cards[2].rank
 
       # Miss
       assert_nil @dummy_click_miss.card

data/test/patience/event_handlers/test_drop.rb

@@ -15,7 +15,6 @@ module Patience
       @mouse_pos = Ray::Vector2[361, 243]
       @deck      = Deck.new
       @areas     = { :tableau    => Tableau.new(@deck.shuffle_off! 28),
-                     :waste      => Waste.new,
                      :foundation => Foundation.new }
       @click     = EventHandler::Click.new(@mouse_pos, @areas)
       @drop      = Dummy.new(@click, @areas)
@@ -90,13 +89,13 @@ module Patience
     end
 
     test 'A dropped card can be called off' do
-      assert_equal Ray::Vector2[361, 243], @drop.card_to_drop.pos
+      assert_equal Ray::Vector2[361, 205], @drop.card_to_drop.pos
 
       @drop.card_to_drop.pos = Ray::Vector2[0, 0]
       assert_equal Ray::Vector2[0, 0], @drop.card_to_drop.pos
 
       @drop.send(:call_off)
-      assert_equal Ray::Vector2[361, 243], @drop.card_to_drop.pos
+      assert_equal Ray::Vector2[361, 205], @drop.card_to_drop.pos
     end
 
     test 'A dropped card can be added to the pile beneath' do
@@ -153,22 +152,22 @@ module Patience
     end
 
     test 'A dropped card can be put in Foundation' do
-      @click = EventHandler::Click.new(Ray::Vector2[32, 165], @areas)
+      @click = EventHandler::Click.new(Ray::Vector2[32, 176], @areas)
       @drop = Dummy.new(@click, @areas)
-      @drop.card_to_drop.pos = Ray::Vector2[362, 23]
+      @drop.card_to_drop.pos = Ray::Vector2[467, 24]
       fill_attributes_up(@drop)
       @drop.send(:put_in_foundation)
-      assert_equal 1, @areas[:foundation].piles[0].size
+      assert_equal 1, @areas[:foundation].piles[1].size
 
       last_card = @areas[:tableau].piles[2].cards.last
       @areas[:tableau].piles[2].cards.delete(last_card)
       @areas[:tableau].piles[2].cards.last.flip!
       @click = EventHandler::Click.new(Ray::Vector2[252, 192], @areas)
       @drop = Dummy.new(@click, @areas)
-      @drop.card_to_drop.pos = Ray::Vector2[362, 23]
+      @drop.card_to_drop.pos = Ray::Vector2[467, 24]
       fill_attributes_up(@drop)
       @drop.send(:put_in_foundation)
-      assert_equal 2, @areas[:foundation].piles[0].size
+      assert_equal 2, @areas[:foundation].piles[1].size
     end
 
   end

data/test/patience/test_foundation.rb

@@ -16,13 +16,13 @@ module Patience
     end
 
     test 'Overall position of foundation can be gotten' do
-      assert_equal Ray::Vector2[361, 23], @foundation.pos
-      assert_equal Ray::Vector2[361, 23], @foundation.piles.first.pos
+      assert_equal Ray::Vector2[356, 23], @foundation.pos
+      assert_equal Ray::Vector2[356, 23], @foundation.piles.first.pos
     end
 
     test 'Particular position of a pile in foundation can be gotten' do
-      assert_equal Ray::Vector2[471, 23], @foundation.piles[1].pos
-      assert_equal Ray::Vector2[581, 23], @foundation.piles[2].pos
+      assert_equal Ray::Vector2[466, 23], @foundation.piles[1].pos
+      assert_equal Ray::Vector2[576, 23], @foundation.piles[2].pos
     end
 
     test 'Foundation can be disposed in the window' do

data/test/patience/test_processable.rb

@@ -17,7 +17,7 @@ module Patience
     def setup
       @dummy = Dummy.new
       @mouse_pos_miss = Ray::Vector2[0, 0]
-      @mouse_pos_hit = Ray::Vector2[32, 166]
+      @mouse_pos_hit = Ray::Vector2[45, 176]
       @deck = Deck.new
       @areas = { :tableau    => Tableau.new(@deck.shuffle_off! 28),
                  :stock      => Stock.new(@deck.shuffle_off! 24),
@@ -63,7 +63,7 @@ module Patience
       assert_equal Tableau, @dummy.find_area_in(@areas) { |area|
                               area.hit?(@mouse_pos_hit)
                             }.class
-      mouse_pos_hit_stock = Ray::Vector2[31, 65]
+      mouse_pos_hit_stock = Ray::Vector2[32, 65]
       assert_equal Stock, @dummy.find_area_in(@areas) { |area|
                             area.hit?(mouse_pos_hit_stock)
                           }.class
@@ -83,7 +83,7 @@ module Patience
     end
 
     test 'Processable can find a card' do
-      mouse_pos_hit_stock = Ray::Vector2[31, 65]
+      mouse_pos_hit_stock = Ray::Vector2[32, 65]
       assert_equal Card, @dummy.find_card_in(@areas) { |card|
                            card.hit?(@mouse_pos_hit)
                          }.class
@@ -131,7 +131,7 @@ module Patience
 
     test 'Processable can count an offset' do
       @dummy.find_all(@areas, @mouse_pos_hit)
-      assert_equal Ray::Vector2[-1, -1],
+      assert_equal Ray::Vector2[-14, -1],
                    @dummy.pick_up(@areas[:tableau].cards[0], @mouse_pos_hit)
     end
 
@@ -140,18 +140,13 @@ module Patience
       assert @dummy.stock?
     end
 
-    test 'Processable can check, if Waste has been hit' do
-      @dummy.find_all(@areas, Ray::Vector2[160, 40])
-      assert @dummy.waste?
-    end
-
     test 'Processable can check, if Tableau has been hit' do
-      @dummy.find_all(@areas, Ray::Vector2[32, 166])
+      @dummy.find_all(@areas, Ray::Vector2[32, 176])
       assert @dummy.tableau?
     end
 
     test 'Processable can check, if Foundation has been hit' do
-      @dummy.find_all(@areas, Ray::Vector2[590, 40])
+      @dummy.find_all(@areas, Ray::Vector2[577, 24])
       assert @dummy.foundation?
     end
 

data/test/patience/test_rank.rb

@@ -84,5 +84,13 @@ module Patience
       refute ace_rank.king?
     end
 
+    test "A rank can be checked, if it's a queen" do
+      ace_rank = Patience::Card::Rank::Ace.new
+      queen_rank = Patience::Card::Rank::Queen.new
+
+      assert queen_rank.queen?
+      refute ace_rank.queen?
+    end
+
   end
 end

data/test/patience/test_stock.rb

@@ -28,8 +28,8 @@ module Patience
     end
 
     test 'The overall position of Stock can be gotten' do
-      assert_equal Ray::Vector2[31, 23], @stock.pos
-      assert_equal Ray::Vector2[31, 23], @stock.piles.first.pos
+      assert_equal Ray::Vector2[31, 27], @stock.pos
+      assert_equal Ray::Vector2[31, 27], @stock.piles.first.pos
     end
 
     test 'Stock can be disposed in the window' do

data/test/patience/test_tableau.rb

@@ -26,14 +26,14 @@ module Patience
     end
 
     test 'The overall position of Tableau can be gotten' do
-      assert_equal Ray::Vector2[31, 165], @tableau.pos
-      assert_equal Ray::Vector2[31, 165], @tableau.piles.first.pos
+      assert_equal Ray::Vector2[31, 175], @tableau.pos
+      assert_equal Ray::Vector2[31, 175], @tableau.piles.first.pos
     end
 
     test 'Particular position of a pile in Tableau can be gotten' do
-      assert_equal Ray::Vector2[141, 165], @tableau.piles[1].pos
-      assert_equal Ray::Vector2[251, 165], @tableau.piles[2].pos
-      assert_equal Ray::Vector2[691, 165], @tableau.piles.last.pos
+      assert_equal Ray::Vector2[141, 175], @tableau.piles[1].pos
+      assert_equal Ray::Vector2[251, 175], @tableau.piles[2].pos
+      assert_equal Ray::Vector2[691, 175], @tableau.piles.last.pos
     end
 
     test 'Tableau can be disposed in the window' do
@@ -46,11 +46,11 @@ module Patience
     end
 
     test 'Cards in Tableau have a margin along the Y axis' do
-      assert_equal Ray::Vector2[31, 165], @tableau.piles[0].cards[0].pos
-      assert_equal Ray::Vector2[251, 191], @tableau.piles[2].cards[1].pos
-      assert_equal Ray::Vector2[471, 191], @tableau.piles[4].cards[1].pos
-      assert_equal Ray::Vector2[581, 217], @tableau.piles[5].cards[2].pos
-      assert_equal Ray::Vector2[691, 321], @tableau.piles.last.cards.last.pos
+      assert_equal Ray::Vector2[31, 175], @tableau.piles[0].cards[0].pos
+      assert_equal Ray::Vector2[251, 185], @tableau.piles[2].cards[1].pos
+      assert_equal Ray::Vector2[471, 185], @tableau.piles[4].cards[1].pos
+      assert_equal Ray::Vector2[581, 195], @tableau.piles[5].cards[2].pos
+      assert_equal Ray::Vector2[691, 235], @tableau.piles.last.cards.last.pos
     end
 
   end

data/test/patience/test_version.rb

@@ -4,7 +4,7 @@ module Patience
   class TestVERSION < TestCase
 
     test 'The Patience version is correct' do
-      assert_equal "0.1.0", Patience::VERSION
+      assert_equal "0.1.1", Patience::VERSION
     end
 
   end

data/test/patience/test_waste.rb

@@ -20,8 +20,8 @@ module Patience
     end
 
     test 'Overall position of Waste can be gotten' do
-      assert_equal Ray::Vector2[141, 23], @waste.pos
-      assert_equal Ray::Vector2[141, 23], @waste.piles.first.pos
+      assert_equal Ray::Vector2[141, 27], @waste.pos
+      assert_equal Ray::Vector2[141, 27], @waste.piles.first.pos
     end
 
     test 'Waste can be disposed in the window' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: patience
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-08 00:00:00.000000000 Z
+date: 2012-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ray
-  requirement: &76654590 !ruby/object:Gem::Requirement
+  requirement: &85106680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: 0.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *76654590
+  version_requirements: *85106680
 description: Klondike solitaire game which is built with help of Ray game library.
 email: kyrylosilin@gmail.com
 executables:
@@ -36,8 +36,11 @@ files:
 - lib/patience/event_handlers/drop.rb
 - lib/patience/event_handlers/click.rb
 - lib/patience/event_handlers/drag.rb
+- lib/patience/sprites/table_bg.png
 - lib/patience/sprites/empty_stock.png
+- lib/patience/sprites/fully_empty_stock.png
 - lib/patience/sprites/card_deck.png
+- lib/patience/sprites/foundation_bg.png
 - lib/patience/sprites/pile_background.png
 - lib/patience/card.rb
 - lib/patience/suit.rb