patience 0.1.0

data/test/patience/test_card.rb

@@ -0,0 +1,165 @@
+require_relative 'helper'
+
+module Patience
+  class TestCard < TestCase
+
+    def setup
+      @card = Card.new(13, 3)
+      @ranks = %w[Two Three Four Five Six Seven Eight
+               Nine Ten Jack Queen King Ace].map { |rank|
+                 "Patience::Card::Rank::#{rank}".constantize
+               }
+      @suits = %w[Heart Diamond Spade Club].map { |suit|
+        "Patience::Card::Suit::#{suit}".constantize
+      }
+    end
+
+    test 'A card accepts only valid ranks' do
+      @ranks.size.times { |i| assert Card.new(i+1, 1) }
+      assert_raises(Card::DefunctRank) { Card.new(0, 1)   }
+      assert_raises(Card::DefunctRank) { Card.new(14, 2)  }
+      assert_raises(Card::DefunctRank) { Card.new(-5, 3)  }
+      assert_raises(Card::DefunctRank) { Card.new(114, 2) }
+    end
+
+    test 'A card accepts only valid suits' do
+      @suits.size.times { |i| assert Card.new(13, i+1) }
+      assert_raises(Card::DefunctSuit) { Card.new(6, 0)  }
+      assert_raises(Card::DefunctSuit) { Card.new(11, 5)  }
+      assert_raises(Card::DefunctSuit) { Card.new(10, -3) }
+      assert_raises(Card::DefunctSuit) { Card.new(8, 144) }
+    end
+
+    test 'A card has rank' do
+      assert_respond_to @card, :rank
+    end
+
+    test 'A card rank can be represented as integer' do
+      assert_equal 4,  Card.new(4, 2).rank.to_i
+      assert_equal 1,  Card.new(1, 2).rank.to_i
+      assert_equal 13, Card.new(13, 2).rank.to_i
+    end
+
+    test 'A card rank can be represented as string' do
+      assert_equal "King", Card.new(13, 3).rank.to_s
+      assert_equal "Ace",  Card.new(1, 4).rank.to_s
+      assert_equal "Five", Card.new(5, 2).rank.to_s
+    end
+
+    test 'A card has suit' do
+      assert_respond_to @card, :suit
+    end
+
+    test 'A card suit can be represented as integer' do
+      assert_equal 1, Card.new(4, 1).suit.to_i
+      assert_equal 4, Card.new(1, 4).suit.to_i
+      assert_equal 3, Card.new(13, 3).suit.to_i
+    end
+
+    test 'A card suit can be represented as string' do
+      assert_equal "Spades",   Card.new(13, 3).suit.to_s
+      assert_equal "Clubs",    Card.new(1, 4).suit.to_s
+      assert_equal "Diamonds", Card.new(5, 2).suit.to_s
+    end
+
+    test 'A card can be of the red suit' do
+      assert Card.new(5, 1).suit.red?
+      assert Card.new(12, 2).suit.red?
+      refute Card.new(12, 3).suit.red?
+      refute Card.new(1, 4).suit.red?
+    end
+
+    test 'A card can be of the black suit' do
+      assert Card.new(2, 3).suit.black?
+      assert Card.new(2, 4).suit.black?
+      refute Card.new(10, 2).suit.black?
+      refute Card.new(5, 1).suit.black?
+    end
+
+    test 'A card can be readable by human' do
+      assert_equal "King of Spades",  @card.to_s
+      assert_equal "Ace of Hearts",   Card.new(1, 1).to_s
+      assert_equal "Six of Diamonds", Card.new(6, 2).to_s
+    end
+
+    test 'A card has sprite' do
+      assert_respond_to @card, :sprite
+    end
+
+    test "Card's sprite sheet has size" do
+      assert_respond_to @card.sprite, :sheet_size
+    end
+
+    test "Card's sprite sheet has position" do
+      assert_respond_to @card.sprite, :sheet_pos
+    end
+
+    test 'A card can turn its face upwards' do
+      assert @card.face_up
+      assert_equal [13, 3], @card.face_up
+    end
+
+    test 'A card can be checked, if its face looks upwards' do
+      assert @card.face_up?
+      refute @card.face_down?
+    end
+
+    test 'A card can turn its face downwards' do
+      assert @card.face_down
+      assert_equal [0, 0], @card.face_down
+    end
+
+    test 'A card can be checked, if its face looks downwards' do
+      assert @card.face_down
+      @card.sprite.sheet_pos = [0, 0]
+      assert @card.face_down?
+      refute @card.face_up?
+    end
+
+    test 'A card can be flipped' do
+      assert @card.face_up?
+      refute @card.face_down?
+
+      @card.flip!
+      assert @card.face_down?
+      refute @card.face_up?
+
+      @card.flip!
+      assert @card.face_up?
+      refute @card.face_down?
+    end
+
+    test 'A card can be checked for overlapping another card' do
+      another_card = Card.new(10, 1)
+      another_card.pos = Ray::Vector2[20, 20]
+      assert @card.overlaps?(another_card)
+      assert another_card.overlaps?(@card)
+
+      another_card.pos = Ray::Vector2[200, 200]
+      refute @card.overlaps?(another_card)
+      refute another_card.overlaps?(@card)
+
+      equal_card = Card.new(10, 1)
+      equal_card.pos = Ray::Vector2[200, 200]
+      assert_equal another_card.pos, equal_card.pos
+      refute another_card.overlaps?(equal_card)
+      refute equal_card.overlaps?(another_card)
+    end
+
+    test 'Cards can be checked for equality on the basis of ranks and suits' do
+      same_card = Card.new(13, 3)
+      only_same_rank = Card.new(13, 1)
+      only_same_suit = Card.new(1, 3)
+      not_same_at_all = Card.new(5, 4)
+
+      assert @card.eql?(same_card)
+      assert same_card.eql?(@card)
+      refute @card.eql?(only_same_rank)
+      refute @card.eql?(only_same_suit)
+      refute only_same_suit.eql?(@card)
+      refute @card.eql?(not_same_at_all)
+      refute not_same_at_all.eql?(@card)
+    end
+
+  end
+end

data/test/patience/test_cursor.rb

@@ -0,0 +1,77 @@
+require_relative 'helper'
+
+module Patience
+  class TestCursor < TestCase
+
+    def setup
+      @cursor = Cursor.new
+      @card   = Card.new(1, 3)
+      @areas  = { :area => Area.new }
+      @areas[:area].piles.first << @card
+
+      offset = Ray::Vector2[20, 20]
+      mouse_pos = Ray::Vector2.new
+
+      @cursor.mouse_pos = mouse_pos
+      @cursor.click = EventHandler::Click.new(mouse_pos, @areas)
+      @cursor.drag  = EventHandler::Drag.new(@cursor)
+      @cursor.drop  = EventHandler::Drop.new(@cursor, @areas)
+    end
+
+    test 'A cursor can drop objects' do
+      assert @cursor.click
+      assert @cursor.drag
+
+      @cursor.drop!
+
+      refute @cursor.click
+      refute @cursor.drag
+    end
+
+    test 'A cursor can check, whether it clicked something' do
+      assert @cursor.clicked_something?
+
+      @cursor.drop!
+
+      refute @cursor.clicked_something?
+    end
+
+    test 'A cursor can check, whether it still hovers the clicked object' do
+      assert @cursor.still_on_something?
+
+      @areas[:area].piles.first << @card
+      @cursor.click = EventHandler::Click.new(@cursor.mouse_pos, @areas)
+      assert @cursor.still_on_something?
+
+      @cursor.mouse_pos = Ray::Vector2[1000, 1000]
+      refute @cursor.still_on_something?
+
+      @cursor.card.sprite.pos = @cursor.mouse_pos
+      assert @cursor.still_on_something?
+
+    end
+
+    test 'A cursor can check, if the object is movable' do
+      assert @cursor.movable?
+      @cursor.card.face_down
+      refute @cursor.movable?
+
+      @cursor.drop!
+
+      refute @cursor.movable?
+    end
+
+    test 'A cursor can check whether it is carrying a card' do
+      assert @cursor.carrying_card?
+
+      @cursor.drop!
+
+      refute @cursor.carrying_card?
+
+      cursor = Cursor.new
+      cursor.click = EventHandler::Click.new(Ray::Vector2[800, 800], @areas)
+      refute cursor.carrying_card?
+    end
+
+  end
+end

data/test/patience/test_deck.rb

@@ -0,0 +1,53 @@
+require_relative 'helper'
+
+module Patience
+  class TestDeck < TestCase
+
+    def setup
+      @deck = Deck.new
+      @cards = @deck.cards.map(&:to_s)
+      @ranks = %w[Two Three Four Five Six Seven Eight Nine Ten]
+      @suits = %w[Hearts Diamonds Spades Clubs]
+    end
+
+    def assert_deck_includes_all_suits_of(rank)
+      rank = @ranks[rank-2] unless rank.instance_of? String
+      @suits.each { |suit| assert_includes @cards, "#{rank} of #{suit}" }
+    end
+
+    test 'Initial size of a deck should be equal to 52' do
+      assert_equal 52, @deck.size
+    end
+
+    (2..10).each do |n|
+      define_method "test_initial_deck_has_#{n}_of_each_suit" do
+        assert_deck_includes_all_suits_of n
+      end
+    end
+
+    test 'Initial deck has jacks of each suit' do
+      assert_deck_includes_all_suits_of 'Jack'
+    end
+
+    test 'Initial deck has queens of each suit' do
+      assert_deck_includes_all_suits_of 'Queen'
+    end
+
+    test 'Initial deck has kings of each suit' do
+      assert_deck_includes_all_suits_of 'King'
+    end
+
+    test 'Initial deck has aces of each suit' do
+      assert_deck_includes_all_suits_of 'Ace'
+    end
+
+    test 'Cards of a deck can be accessed via their positon in the deck' do
+      assert_equal 'King of Spades',   @cards[50].to_s
+      assert_equal 'Ace of Clubs',     @cards[3].to_s
+      assert_equal 'Nine of Diamonds', @cards[33].to_s
+      assert_equal 'Ten of Hearts',    @cards[36].to_s
+      assert_equal 'Ace of Hearts',    @cards[0].to_s
+    end
+
+  end
+end

data/test/patience/test_foundation.rb

@@ -0,0 +1,38 @@
+require_relative 'helper'
+
+module Patience
+  class TestFoundationArea < TestCase
+
+    def setup
+      @foundation = Foundation.new
+    end
+
+    test 'Foundation is a child of Area' do
+      assert_kind_of Area, @foundation
+    end
+
+    test 'Initial foundation has no cards' do
+      @foundation.piles.each { |pile| assert_equal 0, pile.cards.size }
+    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
+    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
+    end
+
+    test 'Foundation can be disposed in the window' do
+      @foundation.send(:pos=, [0, 0])
+      assert_equal Ray::Vector2[0, 0], @foundation.pos
+      assert_equal Ray::Vector2[330, 0], @foundation.piles.last.pos
+      @foundation.send(:pos=, [200, 300])
+      assert_equal Ray::Vector2[200, 300], @foundation.pos
+      assert_equal Ray::Vector2[530, 300], @foundation.piles.last.pos
+    end
+
+  end
+end

data/test/patience/test_game.rb

@@ -0,0 +1,29 @@
+require_relative 'helper'
+
+module Patience
+  class TestGame < TestCase
+
+    def setup
+      @game = Patience::Game.new
+      @scene = @game.registered_scene(:game_scene)
+      @scene.register
+      @scene.setup
+    end
+
+    test 'Window size of the game is eight hundred by six hundred pixels' do
+      assert_equal Ray::Vector2[800, 600], @scene.window.size
+    end
+
+    test 'Test the game has GameScene' do
+      assert_instance_of GameScene,
+                         @game.scenes.to_a.find { |scene|
+                           scene.instance_of? GameScene
+                         }
+    end
+
+    test 'Main scene is GameScene' do
+      assert_instance_of GameScene, @game.scenes.current
+    end
+
+  end
+end

data/test/patience/test_pile.rb

@@ -0,0 +1,83 @@
+require_relative 'helper'
+
+module Patience
+  class TestPile < TestCase
+
+    def setup
+      @cards = Array.new(10) { Card.new(12, 3) }
+      @pile = Pile.new(@cards)
+    end
+
+    test 'A pile has cards' do
+      assert @pile.cards
+    end
+
+    test 'A card can be appended to the pile' do
+      @pile << Card.new(13, 3)
+      assert_equal "King of Spades", @pile.cards.last.to_s
+      @pile << Card.new(1, 4)
+      assert_equal "Ace of Clubs", @pile.cards.last.to_s
+    end
+
+    test 'A pile has background' do
+      assert @pile.background
+      assert_instance_of Ray::Sprite, @pile.background
+    end
+
+    test 'The background of a pile can be changed' do
+      assert_equal Ray::Vector2[0, 0], @pile.background.pos
+      @pile.background.pos = [200, 200]
+      path = '../lib/patience/sprites/empty_stock.png'
+      assert @pile.background = Ray::Sprite.new(path_of(path))
+      assert_equal Ray::Vector2[200, 200], @pile.background.pos
+    end
+
+    test 'A pile has position' do
+      assert_equal [0, 0], @pile.pos.to_a
+    end
+
+    test 'The position of a pile can be set' do
+      @pile.pos = [105, 20]
+      assert_equal [105, 20], @pile.pos.to_a
+    end
+
+    test 'Cards can be counted in a pile' do
+      assert_equal 10, @pile.size
+    end
+
+    test 'Cards can be shuffled off from a pile' do
+      assert_equal 6, @pile.shuffle_off!(6).size
+      assert_equal 4, @pile.size
+    end
+
+    test "A pile's last card detects correctly" do
+      assert @pile.last_card?(@cards.last)
+    end
+
+    test 'A pile can tell, if its card has been clicked' do
+      # Pile with cards.
+      assert @pile.hit?(Ray::Vector2[20, 20])
+      refute @pile.hit?(Ray::Vector2[1000, 0])
+
+      # Empty pile.
+      pile = Pile.new
+      assert pile.hit?(Ray::Vector2[20, 20])
+      refute pile.hit?(Ray::Vector2[1000, 0])
+    end
+
+    test 'A pile can tell, if it overlaps with a card' do
+      empty_pile = Pile.new
+      assert empty_pile.overlaps?(@cards[0])
+
+      @cards[0].pos = Ray::Vector2[200, 200]
+      refute empty_pile.overlaps?(@cards[0])
+
+      non_empty_pile = Pile.new([Card.new(13, 3)])
+      assert non_empty_pile.overlaps?(@cards[1])
+
+      @cards[1].pos = Ray::Vector2[200, 200]
+      refute non_empty_pile.overlaps?(@cards[1])
+    end
+
+  end
+end