patience 0.1.0

data/lib/patience/cursor.rb

@@ -0,0 +1,66 @@
+module Patience
+  ###
+  # Patience::Cursor is a high-level class, which deals with all events
+  # in the game. Cursor always knows current position of the mouse.
+  #   cursor = Cursor.new
+  #   always { @cursor.mouse_pos = mouse_pos }
+  #   cursor.clicked_something? #=> false
+  #   cursor.still_on_something? #=> false
+  #
+  class Cursor
+    extend Forwardable
+
+    attr_accessor :mouse_pos, :click, :drag, :drop
+
+    def click!
+      @click.scenario.call
+    end
+
+    # Calls calculated scenario for the drop event and then
+    # refreshes click, drag and drop by setting them to nil.
+    def drop!
+      @drop.scenario.call
+      @click, @drag, @drop = nil, nil, nil
+    end
+
+    # Checks whether cursor clicked something. If so, also checks, if the cursor
+    # is still in boundaries of that object at the time of mouse button release.
+    # Returns true, if this is true. Otherwise, returns false.
+    def clicked_something?
+      click and click.something? and still_on_something?
+    end
+
+    # Checks whether cursor is still over the clicked object by
+    # asking card or pile, if the mouse_pos is within the pale of
+    # them. Returns true, if this is true. Otherwise, returns false.
+    def still_on_something?
+      if carrying_card?
+        card.hit?(mouse_pos)
+      elsif pile
+        pile.hit?(mouse_pos)
+      else
+       false
+      end
+    end
+
+    # Returns true if cursor clicked some card and that card is avaliable
+    # for dragging (e.g. its face is up). Otherwise, returns false.
+    def movable?
+      carrying_card? and draggable?
+    end
+
+    # Returns true if cursor clicked something different from
+    # nothing. And by "something different" I mean any card.
+    def carrying_card?
+      click and card
+    end
+
+    ##
+    # Returns true if the clicked object is drawable. Otherwise,
+    # returns false. In fact, this method exists only for readability.
+    alias :drawable? :movable?
+
+    def_delegators :@click, :card, :pile, :offset, :cards
+    def_delegator  :@drag, :draggable?
+  end
+end

data/lib/patience/deck.rb

@@ -0,0 +1,21 @@
+require_relative 'pile'
+
+module Patience
+  ###
+  # Patience::Deck creates a play deck object, which
+  # contains 52 cards (just like a real world deck!).
+  #   deck = Deck.new(cards) # Just imagine, that we've already created those!
+  #   deck.cards.size #=> 52
+  #
+  class Deck < Pile
+
+    def initialize
+      @cards = []
+
+      Card::Rank.descendants.size.times do |r|
+        Card::Suit.descendants.size.times { |s| @cards << Card.new(r+1, s+1) }
+      end
+    end
+
+  end
+end

data/lib/patience/event_handlers/click.rb

@@ -0,0 +1,99 @@
+require_relative '../processable'
+
+module Patience
+  class EventHandler
+    ###
+    # Click represents a state of every click in the game. Processable module
+    # endows Click with special abilities (the group of "detect" methods).
+    # Every object of Click has the scenario parameter, which is an instance of
+    # the Lambda. Thereby, an action, which should be performed on click, can be
+    # executed lately and lazily (on demand). Scenario is nothing but a bunch
+    # of certain actions, being performed on click.
+    #   cursor.click = EventHandler::Click.new(mouse_pos, areas)
+    #   cursor.click.card #=> Two of Hearts
+    #   cursor.click.card.pos  #=> (0, 0)
+    #   cursor.click.scenario.call # Perform some action on the card.
+    #   cursor.click.card.pos #=> (20, 20)
+    #
+    class Click
+      extend Forwardable
+
+      include Processable
+
+      attr_reader :cards, :offset, :scenario
+
+      def initialize(mouse_pos, areas)
+        @mouse_pos = mouse_pos
+        @areas = areas
+        @area = detect_area
+
+        # If area has been detected, calculate other parameters too.
+        if @area
+          @pile = detect_pile
+          @cards = collect_cards # A clicked card and tail cards.
+          @card = cards.keys.first if @cards # The very clicked card.
+          # Offset for dragged card.
+          @offset = pick_up(@card, mouse_pos) if @card and something?
+
+          @scenario = -> { stock }
+        end
+      end
+
+      protected
+
+      # Finds an area of a card, which was clicked.
+      def detect_area
+        detect_in(@areas, :area) { |area| area.hit?(@mouse_pos) }
+      end
+
+      # Finds a pile of a card, which was clicked.
+      def detect_pile
+        detect_in(@areas, :pile) { |pile| pile.hit?(@mouse_pos) }
+      end
+
+      # Finds a card, which was clicked and tries to find
+      # descending cards, in the pile (if there are any).
+      def collect_cards
+        card = detect_in(@areas, :card) { |card| card.hit?(@mouse_pos) }
+        return card unless card
+
+        n = @pile.size - @pile.cards.index(card)
+        tail_cards = @pile.cards.last(n)
+        Hash[*tail_cards.map { |card| [card, card.pos] }.flatten]
+      end
+
+      # Adds a card from Stock to Waste, if Stock was clicked.
+      def stock
+        if stock?
+          if pile.empty?
+            pile_background = 'patience/sprites/pile_background.png'
+            pile.background = Ray::Sprite.new path_of(pile_background)
+            refill_stock
+          else
+            displace_to_waste if @card
+          end
+
+          if pile.empty?
+            empty_stock = 'patience/sprites/empty_stock.png'
+            pile.background = Ray::Sprite.new path_of(empty_stock)
+          end
+        end
+      end
+
+      # Removes all cards from Stock and adds them to Waste.
+      def refill_stock
+        @areas[:waste].tap { |waste|
+          waste.cards.reverse_each do |card|
+            @areas[:stock].add_from(waste.piles.first, card)
+          end
+        }
+      end
+
+      # Adds clicked card from Stock to Waste.
+      def displace_to_waste
+        @areas[:waste].add_from(@pile, @card)
+      end
+
+    end
+  end
+end

data/lib/patience/event_handlers/drag.rb

@@ -0,0 +1,36 @@
+require_relative '../processable'
+
+module Patience
+  class EventHandler
+    ###
+    # Patience::EventHandler::Drag provides drag objects,
+    # that serves for moving cards in the window.
+    #   areas = { :tableau => Tableau.new }
+    #   cursor.drag = EventHandler::Drag.new(cursor)
+    #   cursor.drag.move(mouse_pos) if cursor.movable?
+    #
+    class Drag
+      include Processable
+
+      def initialize(cursor)
+        @card = cursor.card
+        @tail_cards = cursor.cards
+        @offset = cursor.offset
+      end
+
+      # 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]
+        end
+      end
+
+      # Returns true if there is a card to drag and this card
+      # is turned to its face. Otherwise, returns false.
+      def draggable?
+        card.not.nil? and card.face_up?
+      end
+
+    end
+  end
+end

data/lib/patience/event_handlers/drop.rb

@@ -0,0 +1,147 @@
+require_relative '../processable'
+
+module Patience
+  class EventHandler
+    # Drop's objects handles dropping of the cards. It means, that these
+    # objects decide, what to do with dropped card. For example, they can return
+    # a dropped card to its initial position, cancelling the work of drag event.
+    #   cursor.drop = EventHandler::Drop.new(click, areas)
+    #   # Execute scenario for the drop event,
+    #   # which calculates dynamically.
+    #   cursor.drop.scenario.call
+    #
+    class Drop
+
+      include Processable
+
+      attr_reader :scenario
+
+      def initialize(click, areas)
+        @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
+
+        @scenario = -> {
+          if tableau?
+            put_in_tableau
+          elsif foundation?
+            put_in_foundation
+          else
+            call_off
+          end
+        }
+      end
+
+      protected
+
+      # Finds an area beneath the dropped card.
+      def find_area_beneath
+        detect_in(@areas, :area) { |area| area.piles.include?(@pile_beneath) }
+      end
+
+      # Finds a pile beneath the dropped card.
+      def find_pile_beneath
+        # Find out, if dropped card is a king or an ace.
+        king_or_ace = @card_to_drop.rank.king? || @card_to_drop.rank.ace?
+        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))
+        end
+      end
+
+      # Finds a card beneath the dropped card.
+      def find_card_beneath
+        all_tail_cards = @areas.values.map do |area|
+          area.piles.map { |pile| pile.cards.last }
+        end.flatten.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
+          (case area
+            when Tableau then tableau_conditions?(card)
+            when Foundation then foundation_conditions?(card)
+          end)
+        end
+      end
+
+      # 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.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)
+      end
+
+      # Removes card from its pile and adds to the pile beneath.
+      def add_to_pile_beneath(card)
+        @pile_beneath << @pile.remove(card)
+      end
+
+      # Sets the position of a dropped card to its initial location.
+      def call_off
+        @cards.each { |card, init_pos| card.pos = init_pos }
+      end
+
+      # 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
+        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))
+      end
+
+      # Adds dropped card to one of Tableau's piles, if it's
+      # possible. If not, calls off card to it's initital position.
+      def put_in_tableau
+        if can_put_in_tableau?
+          @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]
+            else
+              card.pos = @pile_beneath.cards[-2].pos + [0, 20]
+            end
+            @pile.cards.last.face_up unless @pile.empty?
+          end
+        else
+          call_off
+        end
+      end
+
+      # Adds dropped card to one of Foundation's piles, if it's
+      # possible. If not, calls off card to it's initital position.
+      def put_in_foundation
+        if can_put_in_foundation?
+          add_to_pile_beneath(@card_to_drop)
+          @pile.cards.last.face_up unless @pile.empty?
+        else
+          call_off
+        end
+      end
+
+    end
+  end
+end

data/lib/patience/foundation.rb

@@ -0,0 +1,30 @@
+require_relative 'area'
+
+module Patience
+  ###
+  # Patience::Area::Foundation is a class, which
+  # represents Foundation area of the game.
+  #   foundation = Area::Foundation.new
+  #   foundation.piles.size #=> 1
+  #
+  class Foundation < Area
+
+    def initialize
+      super([], 4)
+      self.pos = [361, 23]
+    end
+
+    protected
+
+    # Disposes Foundation in the window by specifying coordinates
+    # of every pile in this area, starting from the pos argument.
+    def pos=(pos)
+      x, y, step_x = pos[0], pos[1], 110
+      piles.each do |pile|
+        pile.pos = [x, y]
+        x += step_x # Margin between piles along the axis X.
+      end
+    end
+
+  end
+end

data/lib/patience/game.rb

@@ -0,0 +1,10 @@
+module Patience
+  class Game < Ray::Game
+    def initialize
+      super("Patience", :size => [800, 600])
+      Patience::GameScene.bind(self)
+
+      scenes << :game_scene
+    end
+  end
+end

data/lib/patience/pile.rb

@@ -0,0 +1,78 @@
+module Patience
+  ###
+  # Patience::Pile is aimed to hold cards in the pile :surprise:.
+  # Every pile has its own background sprite and set of cards.
+  #   cards = [Card.new(1, 1), Card.new(1, 2), Card.new(1, 3)]
+  #   random_pile = Pile.new(cards)
+  #   random_pile.background = [10, 10]
+  #
+  class Pile
+    extend Forwardable
+
+    attr_accessor :cards, :background
+
+    def initialize(cards=[])
+      @cards = cards
+      pile_background = 'patience/sprites/pile_background.png'
+      @background = Ray::Sprite.new path_of(pile_background)
+    end
+
+    # Changes background sprite of the pile considering position of the old one.
+    def background=(bg)
+      bg.pos = @background.pos
+      @background = bg
+    end
+
+    # Throws off 'num' quantity of cards and returns the array of them.
+    def shuffle_off!(num)
+      cards.slice!(0..num-1)
+    end
+
+    # Appends card to the pile considering position of that pile.
+    def <<(other_card)
+      other_card.pos = self.pos
+      cards << other_card
+    end
+
+    # Sets position of the pile. Applies to
+    # the cards in the pile and background both.
+    def pos=(pos)
+      background.pos = *pos
+      cards.each { |card| card.pos = *pos }
+    end
+
+    # Returns true if the given card is the last
+    # card in the pile Otherwise, returns false.
+    def last_card?(card)
+      card == cards.last
+    end
+
+    # Draws pile in the window.
+    def draw_on(win)
+      win.draw(background)
+      cards.each { |card| card.draw_on(win) }
+    end
+
+    # Returns true or card, if there was clicked background or card
+    # in the pile, respectively. Otherwise returns false or nil.
+    def hit?(mouse_pos)
+      background.to_rect.contain?(mouse_pos) or
+      cards.find { |card| card.hit?(mouse_pos) }
+    end
+
+    # If the pile is empty, returns the result of collision detection
+    # of the other_card and background of the pile. If the pile isn't
+    # empty, tries to find a card, which overlaps other_card.
+    def overlaps?(other_card)
+      if cards.empty?
+        background.to_rect.collide?(other_card)
+      else
+        cards.find { |card| card.face_up? and card.overlaps?(other_card) }
+      end
+    end
+
+    def_delegators :@cards, :size, :empty?, :delete
+    def_delegator  :@cards, :delete, :remove
+    def_delegators :@background, :pos, :x, :y
+  end
+end