patience 0.1.0

data/test/patience/event_handlers/test_click.rb

@@ -0,0 +1,142 @@
+require_relative '../helper'
+
+module Patience
+  class TestClick < TestCase
+
+    class Dummy < EventHandler::Click
+      attr_accessor :area, :pile, :card, :cards, :scenario
+
+      def initialize(mouse_pos, areas)
+        @mouse_pos = mouse_pos
+        @areas = areas
+      end
+    end
+
+    def setup
+      @mouse_pos_missclick = Ray::Vector2[0, 0]
+      @mouse_pos_hit = Ray::Vector2[32, 166]
+      @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)
+    end
+
+    def fill_attributes_up(click)
+      click.area  = click.send(:detect_area)
+      click.pile  = click.send(:detect_pile)
+      cards = click.send(:collect_cards)
+      click.cards = cards.map(&:first) if cards
+      click.card  = click.cards.first
+    end
+
+    test 'An area can be selected by click' do
+      assert_nil @dummy_click_hit.area
+      @dummy_click_hit.area = @dummy_click_hit.send(:detect_area)
+      assert_instance_of Tableau, @dummy_click_hit.area
+      assert_kind_of     Area,    @dummy_click_hit.area
+
+      assert_nil @dummy_click_miss.area
+      @dummy_click_miss.area = @dummy_click_miss.send(:detect_area)
+      assert_nil @dummy_click_miss.area
+    end
+
+    test 'A pile can be selected by click' do
+      assert_nil @dummy_click_hit.pile
+      @dummy_click_hit.pile = @dummy_click_hit.send(:detect_pile)
+      assert_instance_of Pile, @dummy_click_hit.pile
+
+      assert_nil @dummy_click_miss.pile
+      @dummy_click_miss.pile = @dummy_click_miss.send(:detect_pile)
+      assert_nil @dummy_click_miss.pile
+    end
+
+    test 'A card can be selected by click' do
+      # Hit
+      tableau_click = Dummy.new(Ray::Vector2[472, 270], @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]
+      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[1].rank
+      assert_instance_of Card::Rank::Two,   tableau_click.cards[2].rank
+
+      # Miss
+      assert_nil @dummy_click_miss.card
+      assert_nil @dummy_click_miss.cards
+      @dummy_click_miss.cards = @dummy_click_miss.send(:collect_cards)
+      assert_nil @dummy_click_miss.card
+      assert_nil @dummy_click_miss.cards
+    end
+
+    test 'Stock can be refilled by a click' do
+      assert_equal 10, @areas[:stock].cards.size
+      assert_equal 0,  @areas[:waste].cards.size
+
+      @areas[:stock].cards.each do |card|
+        @areas[:waste].piles[0] << card
+      end
+      @areas[:stock].piles[0].cards.clear
+
+      assert_equal 0,  @areas[:stock].cards.size
+      assert_equal 10, @areas[:waste].cards.size
+
+      @dummy_click_hit.send(:refill_stock)
+      assert_equal 10, @areas[:stock].cards.size
+      assert_equal 0,  @areas[:waste].cards.size
+    end
+
+    test 'A card can be displaced from Stock to Waste by a click' do
+      assert_equal 10, @areas[:stock].cards.size
+      assert_equal 0,  @areas[:waste].cards.size
+
+      fill_attributes_up(@stock_hit)
+      @stock_hit.send(:displace_to_waste)
+      assert_equal 9, @areas[:stock].cards.size
+      assert_equal 1, @areas[:waste].cards.size
+
+      fill_attributes_up(@stock_hit)
+      @stock_hit.send(:displace_to_waste)
+      assert_equal 8, @areas[:stock].cards.size
+      assert_equal 2, @areas[:waste].cards.size
+    end
+
+    test 'Stock can change its background as a function of conditions' do
+      stock = @areas[:stock].piles[0]
+      @stock_hit.scenario = -> { @stock_hit.send(:stock) }
+      normal_background = @areas[:stock].piles[0].background.object_id
+      assert normal_background, stock.background.object_id
+      assert_equal 10, stock.size
+
+      fill_attributes_up(@stock_hit)
+      @stock_hit.scenario.call
+      assert normal_background, stock.background.object_id
+      assert_equal 9, stock.size
+
+      stock.size.times do
+        fill_attributes_up(@stock_hit)
+        @stock_hit.scenario.call
+      end
+
+      empty_background = stock.background.object_id
+      refute_equal normal_background, empty_background
+      assert_equal 0, stock.size
+
+      fill_attributes_up(@stock_hit)
+      @stock_hit.scenario.call
+      refute_equal empty_background, stock.background.object_id
+      refute_equal empty_background, normal_background
+    end
+
+  end
+end

data/test/patience/event_handlers/test_drag.rb

@@ -0,0 +1,45 @@
+require_relative '../helper'
+
+module Patience
+  class TestDrag < TestCase
+
+    class Dummy < EventHandler::Drag
+      def initialize
+        @card = Card.new(1, 1)
+        @tail_cards = {@card => 0, Card.new(2, 2) => 0, Card.new(3, 3) => 0}
+        @offset = Ray::Vector2[20, 20]
+      end
+    end
+
+    def setup
+      @mouse_pos = Ray::Vector2[0, 0]
+      @dummy = Dummy.new
+      @areas = { :tableau => Tableau.new([Card.new(1, 1)]) }
+      @cursor = Cursor.new
+      @cursor.mouse_pos = @mouse_pos
+      @cursor.click = EventHandler::Click.new(@cursor.mouse_pos, @areas)
+    end
+
+    test 'A drag can move cards' do
+      assert_equal Ray::Vector2[0, 0], @dummy.card.sprite.pos
+
+      @mouse_pos += [200, 200]
+      @dummy.move(@mouse_pos)
+      assert_equal Ray::Vector2[220, 220], @dummy.card.sprite.pos
+
+      @mouse_pos += [-231, -365]
+      @dummy.move(@mouse_pos)
+      assert_equal Ray::Vector2[-11, -145], @dummy.card.sprite.pos
+    end
+
+    test 'A drag can check, whether a card is draggable' do
+      assert @dummy.draggable?
+
+      @cursor.mouse_pos = Ray::Vector2[800, 500]
+      @cursor.click = EventHandler::Click.new(@cursor.mouse_pos, @areas)
+      drag = EventHandler::Drag.new(@cursor)
+      refute drag.draggable?
+    end
+
+  end
+end

data/test/patience/event_handlers/test_drop.rb

@@ -0,0 +1,175 @@
+require_relative '../helper'
+
+module Patience
+  class TestDrop < TestCase
+
+    class EventHandler::Click
+      attr_accessor :mouse_pos
+    end
+
+    class Dummy < EventHandler::Drop
+      attr_accessor :card_to_drop, :pile_beneath, :card_beneath, :area, :pile
+    end
+
+    def setup
+      @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)
+    end
+
+    def fill_attributes_up(drop)
+      @drop.card_beneath = @drop.send(:find_card_beneath)
+      @drop.pile_beneath = @drop.send(:find_pile_beneath)
+    end
+
+    test 'An area can be found by drop' do
+      @drop.card_to_drop.pos = Ray::Vector2[0, 0]
+      fill_attributes_up(@drop)
+
+      assert_nil @drop.send(:find_area_beneath)
+
+      @drop.card_to_drop.pos = Ray::Vector2[252, 218]
+      fill_attributes_up(@drop)
+      assert_nil @drop.send(:find_area_beneath)
+
+      @drop.card_to_drop.pos = Ray::Vector2[472, 270]
+      fill_attributes_up(@drop)
+      assert_equal Tableau, @drop.send(:find_area_beneath).class
+
+      assert_kind_of Area, @drop.send(:find_area_beneath)
+    end
+
+    test 'A pile can be found by drop' do
+      @drop.card_to_drop.pos = Ray::Vector2[0, 0]
+      assert_nil @drop.send(:find_pile_beneath)
+
+      @drop.card_to_drop.pos = Ray::Vector2[252, 218]
+      assert_nil @drop.send(:find_pile_beneath)
+
+      @drop.card_to_drop.pos = Ray::Vector2[472, 270]
+      @drop.card_beneath = @drop.send(:find_card_beneath)
+
+      assert_equal Pile, @drop.send(:find_pile_beneath).class
+    end
+
+    test 'A card can be found by drop' do
+      @drop.card_to_drop.pos = Ray::Vector2[0, 0]
+      assert_nil @drop.send(:find_card_beneath)
+
+      @drop.card_to_drop.pos = Ray::Vector2[252, 218]
+      assert_nil @drop.send(:find_card_beneath)
+
+      @drop.card_to_drop.pos = Ray::Vector2[472, 270]
+      assert_equal Card, @drop.send(:find_card_beneath).class
+    end
+
+    test 'A drop can decide whether a card meets conditions of Tableau' do
+      @drop.card_to_drop = Card.new(8, 1)
+      nine_of_clubs    = Card.new(9, 4)
+      king_of_diamonds = Card.new(13, 2)
+      nine_of_hearts   = Card.new(9, 1)
+
+      assert @drop.send(:tableau_conditions?, nine_of_clubs)
+      refute @drop.send(:tableau_conditions?, king_of_diamonds)
+      refute @drop.send(:tableau_conditions?, nine_of_hearts)
+    end
+
+    test 'A drop can decide whether a card meets conditions of Foundation' do
+      @drop.card_to_drop = Card.new(10, 1)
+      nine_of_clubs    = Card.new(9, 4)
+      king_of_diamonds = Card.new(13, 2)
+      nine_of_hearts   = Card.new(9, 1)
+
+      refute @drop.send(:foundation_conditions?, nine_of_clubs)
+      refute @drop.send(:foundation_conditions?, king_of_diamonds)
+      assert @drop.send(:foundation_conditions?, nine_of_hearts)
+    end
+
+    test 'A dropped card can be called off' do
+      assert_equal Ray::Vector2[361, 243], @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
+    end
+
+    test 'A dropped card can be added to the pile beneath' do
+      @drop.pile_beneath = Pile.new
+      @drop.pile = Pile.new([Card.new(1, 1)])
+
+      assert_equal 0, @drop.pile_beneath.size
+      assert_equal 1, @drop.pile.size
+
+      @drop.send(:add_to_pile_beneath, @drop.pile.cards[0])
+      assert_equal 1, @drop.pile_beneath.size
+      assert_instance_of Card, @drop.pile_beneath.cards[0]
+      assert_equal Card::Rank::Ace, @drop.pile_beneath.cards[0].rank.class
+      assert_equal 0, @drop.pile.size
+    end
+
+    # Not complete.
+    test "A dropped card can be checked, if it's allowed to be put in Tableau" do
+      @drop.card_to_drop.pos = Ray::Vector2[472, 270]
+      fill_attributes_up(@drop)
+      assert @drop.send(:can_put_in_tableau?)
+
+      @drop.card_to_drop = Card.new(1, 1)
+      @drop.card_to_drop.pos = Ray::Vector2[472, 270]
+      refute @drop.send(:can_put_in_tableau?)
+    end
+
+    # Not complete.
+    test "A dropped card can be checked, if it's allowed to be put in Foundation" do
+      @drop.card_to_drop = Card.new(1, 1)
+      @drop.card_to_drop.pos = Ray::Vector2[362, 23]
+      fill_attributes_up(@drop)
+      assert @drop.send(:can_put_in_foundation?)
+
+      @drop.card_to_drop = Card.new(10, 1)
+      refute @drop.send(:can_put_in_foundation?)
+    end
+
+    test 'A dropped card can be put in Tableau' do
+      @drop.card_to_drop.pos = Ray::Vector2[472, 270]
+      fill_attributes_up(@drop)
+      assert_equal 5, @areas[:tableau].piles[4].size
+      @drop.send(:put_in_tableau)
+      assert_equal 6, @areas[:tableau].piles[4].size
+
+      @areas[:tableau].piles[3] << Card.new(2, 3)
+      @areas[:tableau].piles[3].cards.last.pos = @mouse_pos
+      @click = EventHandler::Click.new(@mouse_pos, @areas)
+      @drop = Dummy.new(@click, @areas)
+      @drop.card_to_drop.pos = Ray::Vector2[472, 270]
+      fill_attributes_up(@drop)
+      @drop.send(:put_in_tableau)
+      assert_equal 7, @areas[:tableau].piles[4].size
+    end
+
+    test 'A dropped card can be put in Foundation' do
+      @click = EventHandler::Click.new(Ray::Vector2[32, 165], @areas)
+      @drop = Dummy.new(@click, @areas)
+      @drop.card_to_drop.pos = Ray::Vector2[362, 23]
+      fill_attributes_up(@drop)
+      @drop.send(:put_in_foundation)
+      assert_equal 1, @areas[:foundation].piles[0].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]
+      fill_attributes_up(@drop)
+      @drop.send(:put_in_foundation)
+      assert_equal 2, @areas[:foundation].piles[0].size
+    end
+
+  end
+end

data/test/patience/helper.rb

@@ -0,0 +1,8 @@
+require 'minitest/autorun'
+require_relative '../../lib/patience'
+
+class TestCase < MiniTest::Unit::TestCase
+  def self.test(name, &blk)
+    define_method('test_' + name, &blk) if blk
+  end
+end

data/test/patience/scenes/test_game_scene.rb

@@ -0,0 +1,14 @@
+require_relative '../helper'
+
+module Patience
+  class TestGameScene < MiniTest::Unit::TestCase
+
+    def setup
+      @game = Patience::Game.new
+      @scene = @game.registered_scene(:game_scene)
+      @scene.register
+      @scene.setup
+    end
+
+  end
+end

data/test/patience/test_area.rb

@@ -0,0 +1,74 @@
+require_relative 'helper'
+
+module Patience
+  class TestArea < TestCase
+
+    def setup
+      @area = Area.new
+      @cards = [Card.new(1, 1)]
+    end
+
+    test 'A new area should contain at least one pile' do
+      assert_equal 1, Area.new.piles.size
+    end
+
+    test 'An area can contain several piles' do
+      assert_equal 1,   Area.new(@cards, 1).piles.size
+      assert_equal 10,  Area.new(@cards, 10).piles.size
+      assert_equal 100, Area.new(@cards, 100).piles.size
+    end
+
+    test 'An area can return array of the piles' do
+      assert_instance_of Array, @area.piles
+      assert_instance_of Pile,  @area.piles.first
+    end
+
+    test 'An area can be disposed' do
+      assert_equal Ray::Vector2[0, 0], @area.piles[0].pos
+      @area.pos = [20, 20]
+      assert_equal Ray::Vector2[20, 20], @area.piles[0].pos
+      @area.pos = [-100, 20]
+      assert_equal Ray::Vector2[-100, 20], @area.piles[0].pos
+
+      area = Area.new([], 4)
+      assert_equal Ray::Vector2[0, 0], area.piles[0].pos
+      assert_equal Ray::Vector2[0, 0], area.piles[3].pos
+      area.pos = [20, 20]
+      assert_equal Ray::Vector2[20, 20], area.piles[0].pos
+      assert_equal Ray::Vector2[20, 20], area.piles[3].pos
+      area.pos = [-100, 20]
+      assert_equal Ray::Vector2[-100, 20], area.piles[0].pos
+      assert_equal Ray::Vector2[-100, 20], area.piles[3].pos
+    end
+
+    test 'An area can tell its position' do
+      assert_equal Ray::Vector2[0, 0], @area.pos
+      @area.pos = [20, 20]
+      assert_equal Ray::Vector2[20, 20], @area.pos
+      @area.pos = [-100, 20]
+      assert_equal Ray::Vector2[-100, 20], @area.pos
+    end
+
+    test 'An area can show all its cards' do
+      assert_equal [], @area.cards
+      @area.piles[0].cards << @cards
+      assert_equal ["Ace of Hearts"], @area.cards.map(&:to_s)
+    end
+
+    test 'An area can tell, if its card has been clicked' do
+      assert @area.hit?(Ray::Vector2[20, 20])
+      refute @area.hit?(Ray::Vector2[1000, 0])
+    end
+
+    test 'A card can be added to the first pile of area from the given pile' do
+      pile = Pile.new([Card.new(1, 1)])
+      assert pile.cards.first.face_up?
+      assert_equal 0, @area.cards.size
+      @area.add_from(pile, pile.cards.first)
+      assert_equal 1, @area.cards.size
+      assert @area.cards.first.face_down?
+      assert_instance_of Card, @area.cards.first
+    end
+
+  end
+end