patience 0.1.0

data/lib/patience/processable.rb

@@ -0,0 +1,87 @@
+module Patience
+  module Processable
+    attr_reader :area, :pile, :card
+
+    # Finds area or pile, or card (depends on the option) in
+    # the areas. If the option is wrong, raises ArgumentError.
+    def detect_in(areas, option, &block)
+      case option
+        when :area then find_area_in(areas, &block)
+        when :pile then find_pile_in(areas, &block)
+        when :card then find_card_in(areas, &block)
+      else
+        raise ArgumentError, "Unknown option: #{option}"
+      end
+    end
+
+    # Returns area, which is being clicked.
+    def find_area_in(areas)
+      areas.values.find { |area| yield(area) }
+    end
+
+    # Returns pile, which is being clicked.
+    def find_pile_in(areas)
+      find_area_in(areas) do |area|
+        pile = area.piles.find { |pile| yield(pile) }
+        return pile unless pile.nil?
+      end
+      nil
+    end
+
+    # Returns card, which is being clicked.
+    def find_card_in(areas)
+      find_pile_in(areas) do |pile|
+        card = pile.cards.reverse.find { |card| yield(card) }
+        return card unless card.nil?
+      end
+      nil
+    end
+
+    # Returns array, containing gathered hit elements.
+    def to_a
+      [area, pile, card]
+    end
+
+    # Returns hash, containing gathered hit elements.
+    def to_h
+      { :area => area, :pile => pile, :card => card }
+    end
+
+    # Returns true, if there hasn't been found something.
+    def nothing?
+      to_a.compact.size.zero?
+    end
+
+    # Returns true, if there's been found something. Opposite of #nothing?.
+    def something?
+      not nothing?
+    end
+
+    # Returns subtraction between card and mouse position at
+    # the moment of click, only if cursor clicked the card.
+    def pick_up(card, mouse_pos)
+      card.pos - mouse_pos
+    end
+
+    # Returns true, if the clicked area is Stock.
+    def stock?
+      area.instance_of? Stock
+    end
+
+    # Returns true, if the clicked area is Waste.
+    def waste?
+      area.instance_of? Waste
+    end
+
+    # Returns true, if the clicked area is Tableau.
+    def tableau?
+      area.instance_of? Tableau
+    end
+
+    # Returns true, if the clicked area is Foundation.
+    def foundation?
+      area.instance_of? Foundation
+    end
+
+  end
+end

data/lib/patience/rank.rb

@@ -0,0 +1,56 @@
+module Patience
+  class Card
+    ###
+    # Rank class provides underlying methods for every rank.
+    class Rank
+      ##
+      # This lambda defines the new class, designed to be a child of Rank.
+      create_rank_class = lambda { |num|
+        Class.new(Rank) do
+          include Comparable
+
+          define_method :initialize do
+            @num = num
+          end
+
+          # Returns integer representation of the rank. Basically, it's
+          # the position of the card in the ascending row of card ranks.
+          def to_i
+            @num
+          end
+
+        end
+      }
+
+      # Dynamically create rank classes.
+      %w[Ace Two Three Four Five Six Seven
+         Eight Nine Ten Jack Queen King].each_with_index do |class_name, i|
+        Rank.const_set(class_name, create_rank_class.call(i+1))
+      end
+
+      # Returns string representation of a rank. It asks class to
+      # give its full name, exscinding everything but its actual name.
+      def to_s
+        "#{self.class.name.demodulize}"
+      end
+
+      # Compares two ranks with each other. Based on integer values.
+      def <=>(other_rank)
+        @num <=> other_rank.to_i
+      end
+
+      def ace?
+        @num == 1
+      end
+
+      def king?
+        @num == 13
+      end
+
+      def higher_by_one_than?(other_rank)
+        @num - other_rank.to_i == 1
+      end
+
+    end
+  end
+end

data/lib/patience/scenes/game_scene.rb

@@ -0,0 +1,66 @@
+module Patience
+  ###
+  # Patience::GameScene is a main scene of the game. All stuff happens here.
+  class GameScene < Ray::Scene
+
+    def setup
+      @bg_color   = Ray::Color.new(31, 95, 25)
+      @cursor     = Cursor.new
+      @deck       = Deck.new
+      @deck.cards.shuffle!
+
+      @tableau    = Tableau.new(@deck.shuffle_off! 28)
+      @stock      = Stock.new(@deck.shuffle_off! 24)
+      @waste      = Waste.new
+      @foundation = Foundation.new
+
+      @areas      = { :tableau    => @tableau,
+                      :stock      => @stock,
+                      :waste      => @waste,
+                      :foundation => @foundation }
+    end
+
+    def register
+      add_hook :quit, method(:exit!)
+      add_hook :key_press, key(:q), method(:exit!)
+
+      # If mouse button pressed, create Click event. If a card has
+      # been clicked, create Drag event. Drag only face up cards.
+      on :mouse_press do
+        @cursor.click = EventHandler::Click.new(@cursor.mouse_pos, @areas)
+        if @cursor.carrying_card?
+          @cursor.drag  = EventHandler::Drag.new(@cursor)
+        end
+      end
+
+      on :mouse_motion do
+        if @cursor.movable? and @cursor.click.not.stock?
+          @cursor.drag.move(@cursor.mouse_pos)
+        end
+      end
+
+      on :mouse_release do
+        @cursor.click! if @cursor.clicked_something?
+        if @cursor.carrying_card?
+          @cursor.drop = EventHandler::Drop.new(@cursor.click, @areas)
+          @cursor.drop! unless @cursor.click.stock?
+        end
+      end
+
+      always do
+        @cursor.mouse_pos = mouse_pos
+      end
+
+    end
+
+    def render(win)
+      win.clear @bg_color
+      @areas.values.to_a.each { |area| area.draw_on(win) }
+      # Draw the card, which is being dragged.
+      if @cursor.drawable?
+        @cursor.click.cards.keys.each { |card| card.draw_on(win) }
+      end
+    end
+
+  end
+end

data/lib/patience/stock.rb

@@ -0,0 +1,20 @@
+require_relative 'area'
+
+module Patience
+  ###
+  # Patience::Area::Stock creates Stock game object. By now, it's backed up only
+  # with methods from the Area class. Every card in Stock is turned to its back.
+  #   stock = Area::Stock.new
+  #   stock = Area::Stock.new([Card.new(1, 1)])
+  #   stock.cards[0].face_down? #=> true
+  #
+  class Stock < Area
+
+    def initialize(cards)
+      super(cards, 1)
+      self.piles.first.cards += @cards.shuffle_off!(24).each(&:face_down)
+      self.pos = [31, 23]
+    end
+
+  end
+end

data/lib/patience/suit.rb

@@ -0,0 +1,73 @@
+module Patience
+  class Card
+    ###
+    # Suit supplies only one method: #red?. The idea is that every
+    # actual suit has its own class, which is inherited from Suit.
+    # Each suit class defines its own #black? method dynamically.
+    class Suit
+      ##
+      # This lambda defines new class, designed to be a child
+      # of Suit and supplied with #black? method, contents of
+      # which depends on the given argument "true_or_false".
+      create_suit_class = lambda { |num, true_or_false|
+        Class.new(Suit) do
+          include Comparable
+
+          define_method :initialize do
+            @num = num
+          end
+
+          # Returns boolean value. For red suits the value
+          # is "false". For black suits the value is "true".
+          define_method :black? do
+            true_or_false
+          end
+
+          # Returns integer representation of a suit.
+          # Example:
+          def to_i
+            @num
+          end
+        end
+      }
+
+      # Create classes for every suit, giving the answer on the question about
+      # their blackness. If the answer is negative, obviously the suit is red.
+      Heart   = create_suit_class.call(1, false)
+      Diamond = create_suit_class.call(2, false)
+      Spade   = create_suit_class.call(3, true)
+      Club    = create_suit_class.call(4, true)
+
+      # Checks whether card is "red" (being not black).
+      # The opposite of the Card#black?. Returns true
+      # if the card is red. Otherwise, returns false.
+      def red?
+        not black?
+      end
+
+      # Returns plural string representation of a suit. It asks class to
+      # give its full name, exscinding everything but its actual name.
+      def to_s
+        "#{self.class.name.demodulize}s"
+      end
+
+      # Compares two suits with each other for equality.
+      def <=>(other_suit)
+        @num <=> other_suit.to_i
+      end
+
+      # 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?)
+      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?)
+      end
+
+    end
+  end
+end

data/lib/patience/tableau.rb

@@ -0,0 +1,42 @@
+require_relative 'area'
+
+module Patience
+  ###
+  # Patience::Area::Foundation is a class, which represents Tableau area of the
+  # game. Every ordinary Tableau should have 7 piles and 28 cards in them. Each
+  # pile has 1 + "serial number of the pile" cards. Every last card in every
+  # pile is turned to its face. The other cards are face down.
+  #   cards = []
+  #   cards = 28.times { cards << Card.new(1, 1) }
+  #   tableau = Tableau.new(cards)
+  #   tableau.piles.size #=> 7
+  #   tableau.cards.size #=> 28
+  #
+  class Tableau < Area
+
+    def initialize(cards)
+      super(cards, 7)
+      @piles.each_with_index { |pile, i| pile.cards += @cards.shuffle_off!(i+1) }
+      self.pos = [31, 165]
+    end
+
+    protected
+
+    # 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
+      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.
+          card.face_down unless pile.last_card?(card)
+        end
+      }
+    end
+
+  end
+end

data/lib/patience/version.rb

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

data/lib/patience/waste.rb

@@ -0,0 +1,18 @@
+require_relative 'area'
+
+module Patience
+  ###
+  # Patience::Area::Waste is a class, which represents Waste area of the
+  # game. By now, it's backed up only with methods from the Area class.
+  #   waste = Area::Waste.new
+  #   waste.piles.size #=> 1
+  #
+  class Waste < Area
+
+    def initialize
+      super([], 1)
+      self.pos = [141, 23]
+    end
+
+  end
+end

data/test/patience/core_ext/test_class.rb

@@ -0,0 +1,28 @@
+require_relative '../helper'
+
+module Patience
+  class TestClass < TestCase
+
+    class Parent
+    end
+
+    class Child1 < Parent
+    end
+
+    class Child2 < Parent
+    end
+
+    class Grandchild1 < Child1
+    end
+
+    class Grandchild2 < Child1
+    end
+
+    test 'Descendats' do
+      assert_equal [Grandchild2, Grandchild1, Child2, Child1], Parent.descendants
+      assert_equal [Grandchild2, Grandchild1], Child1.descendants
+      assert_equal [], Child2.descendants
+    end
+
+  end
+end

data/test/patience/core_ext/test_object.rb

@@ -0,0 +1,15 @@
+require_relative '../helper'
+
+module Patience
+  class TestObject < TestCase
+
+    test 'The not object does negate true to false' do
+      refute nil.not.nil?, "The Not object doesn't negate true to false"
+    end
+
+    test 'The not object does negate false to true' do
+      assert Object.new.not.nil?, "The Not object doesn't negate false to true"
+    end
+
+  end
+end

data/test/patience/core_ext/test_string.rb

@@ -0,0 +1,35 @@
+require_relative '../helper'
+
+module Please
+  module Forgive
+    class Me
+    end
+  end
+end
+
+module Patience
+  class TestString < TestCase
+
+    test 'Demodulize' do
+      assert_equal "Changes", "Going::Through::Changes".demodulize
+    end
+
+    test 'Constantize' do
+      assert_equal Please::Forgive::Me, "Please::Forgive::Me".constantize
+      assert_equal Please::Forgive::Me, "::Please::Forgive::Me".constantize
+      assert_equal Please::Forgive, "Please::Forgive".constantize
+      assert_equal Please::Forgive, "::Please::Forgive".constantize
+      assert_equal Please, "Please".constantize
+      assert_equal Please, "::Please".constantize
+      assert_raises(NameError) { "UnknownClass".constantize }
+      assert_raises(NameError) { "UnknownClass::NotForToffy".constantize }
+      assert_raises(NameError) { "UnknownClass::Please".constantize }
+      assert_raises(NameError) { "UnknownClass::Please::Forgive".constantize }
+      assert_raises(NameError) { "An invalid string".constantize }
+      assert_raises(NameError) { "InvalidClass\n".constantize }
+      assert_raises(NameError) { "Please::TestString".constantize }
+      assert_raises(NameError) { "Please::Forgive::TestString".constantize }
+    end
+
+  end
+end