patience 0.1.0

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+Patience changelog
+==================
+
+## v0.1.0 (March 06, 2012)
+
+* Initial release.

data/Gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+
+gem 'ray', '~> 0.2.0'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,17 @@
+PATH
+  remote: .
+  specs:
+    patience (0.0.0)
+      ray (~> 0.2.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ray (0.2.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  patience!
+  ray (~> 0.2.0)

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012 Kyrylo Silin
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.

data/README.md

@@ -0,0 +1,111 @@
+Patience
+========
+
+* [https://github.com/kyrylo/patience/](https://github.com/kyrylo/patience/ "Home page")
+
+Description
+-----------
+
+![Patience, version 0.1.0](http://img-fotki.yandex.ru/get/5908/98991937.6/0_7259e_d9e01c58_orig "Patience, version 0.1.0")
+
+_Patience_ is a card game (also known as Solitaire), which is written in Ruby.
+The game is based on Ray, a Ruby library for games. Currenlty, _Patience_ runs
+_only_ on GNU/Linux, although, I'm planning to support it on Windows.
+
+How to play
+-----------
+
+The play area of _Patience_ (Solitaire) consits of four zones: Waste, Tableau,
+Stock and Foundation. The goal of the game is to allocate all the cards from
+Tableau to Foundation. You can drag cards from pile to pile with your mouse.
+Remember, you can't drop cards anywhere: there are some rules, restricting that
+mess. Brief rules:
+
+![Patience, rules](http://img-fotki.yandex.ru/get/6101/98991937.7/0_726e0_789437d8_orig "Patience, rules")
+
+### Stock
+
+* In the very beginning of each game comprises of 24 cards
+* A click on Stock reveals its card and moves it to Waste
+* You can't drag cards from Stock
+* You can't drop cards onto Stock
+* If Stock is empty, you can refresh it with cards from Waste (if there are any)
+  by clicking the former again.
+
+### Waste
+
+* In the very beginning of each game has no cards
+* You can drag cards from Waste and drop them onto Tableau
+* You can't drop cards onto Waste
+
+### Tableau
+
+* In the very beginning of the game comprises of 28 cards
+* Consists of 7 piles. Each pile has `number of pile` cards
+* Accepts cards from Waste and other piles from Tableau
+* You can drop _only_ a King onto the freed pile
+* You can move whole (valid) piles onto a proper cards
+* You can drop a card onto a card in the pile, which's lower by one rank and has
+  suit of different color.
+
+  Example:
+
+  ![Correct drop](http://img-fotki.yandex.ru/get/6200/98991937.7/0_726e1_bc6edf54_orig "Correct drop")
+  ![Wrong drop](http://img-fotki.yandex.ru/get/6200/98991937.7/0_726e3_640d9de0_orig "Wrong drop")
+
+### Foundation
+
+* In the very beginning of each game has no cards
+* Consists of 4 piles
+* If the pile of Foundation is empty, it can accept only an Ace.
+* If the pile of Foundation isn't empty, it will accept only cards of the same
+  suit, that are higher by one rank.
+
+### Winning conditions
+
+* All the cards are in Foundation, other zones has no cards.
+
+Requirements
+------------
+
+### Runs on
+
+* GNU/Linux
+
+### Dependencies
+
+* [Ruby](http://ruby-lang.org/ "Ruby")
+  (Tested _only_ on 1.9.3 version)
+
+* [Ray](https://github.com/Mon-Ouie/ray/ "Ray") (0.2.0)
+
+Installation
+------------
+
+### Regular GNU/Linux way
+
+        gem install patience
+
+To launch the game:
+
+        % patience
+
+### Irregular way
+
+        git clone git://github.com/kyrylo/patience.git patience
+
+To launch the game:
+
+        % cd patience
+        % ruby bin/patience
+
+Credits
+-------
+
+* Thanks to [Bil Bas (Spooner)](https://github.com/Spooner "Bil Bas") for giving advices and answering my questions
+* Thanks to [Mon Ouïe](https://github.com/Mon-Ouie "Mon Ouïe") for Ray
+
+License
+-------
+
+The project uses Zlib License. See LICENSE file for more information.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake/testtask'
+
+desc 'Run tests'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/test_*.rb'
+  t.verbose = true
+end
+
+task :default => :test

data/bin/patience

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/patience'
+
+Patience::Game.new.run

data/lib/patience.rb

@@ -0,0 +1,13 @@
+require 'ray'
+require 'forwardable'
+
+def path_of(resource)
+  File.join(File.dirname(__FILE__), resource)
+end
+
+Dir.chdir(File.dirname(__FILE__)) do
+  Dir['patience/event_handlers/*.rb'].each { |eh| require_relative eh }
+  Dir['patience/core_ext/*.rb'].each { |ext| require_relative ext }
+  Dir['patience/scenes/*.rb'].each { |scene| require_relative scene }
+  Dir['patience/*.rb'].each { |file| require_relative file }
+end

data/lib/patience/area.rb

@@ -0,0 +1,62 @@
+module Patience
+  ###
+  # Patience::Area provides area objects, that consist of piles. The goal of
+  # this class is to assemble piles into a logical bundle with a few common
+  # methods, so they could be controlled via only one interface. Basically,
+  # this class is useless on its own. The purpose of Area is to be inherited
+  # by other classes, which are more verbose in their intentions. By default,
+  # Area object instantiates without any cards and only with one pile. Every
+  # new pile would be created empty, even though you feed some cards to the
+  # new object. All the cards you provide to the new object, wouldn't be
+  # placed anywhere. You have to allocate them manually.
+  #   field = Area.new
+  #   field.piles #=> [#<Patience::Pile>]
+  #   filed.piles[0].pos #=> (0, 0)
+  #   field.pos #=> (0, 0)
+  #
+  class Area
+    # Returns an array of piles in the area.
+    attr_reader :piles
+
+    def initialize(cards=[], piles_num=1)
+      @piles = []
+      @cards = Pile.new(cards)
+      piles_num.times { @piles << Pile.new }
+    end
+
+    # Shows position of the area. The position of the very
+    # first pile in the area, counts as its actual position.
+    def pos
+      piles.first.pos
+    end
+
+    # Sets the position of every pile in the area to the same value.
+    def pos=(pos)
+      piles.each { |pile| pile.pos = *pos }
+    end
+
+    # Collects all cards in every pile and returns the array of these
+    # cards. If there are no cards in the area, returns an empty array.
+    def cards
+      piles.inject([]) { |cards, pile| cards << pile.cards }.flatten
+    end
+
+    # Draws each pile of the area in the window.
+    def draw_on(win)
+      piles.each { |pile| pile.draw_on(win) }
+    end
+
+    # Returns pile in the area, which has been
+    # clicked. If there is no such, returns nil.
+    def hit?(mouse_pos)
+      piles.find { |pile| pile.hit?(mouse_pos) }
+    end
+
+    # Adds card from outer_pile to the very first
+    # pile of the area, flipping it en route.
+    def add_from(outer_pile, card)
+      card.flip! and piles.first << outer_pile.remove(card)
+    end
+
+  end
+end

data/lib/patience/card.rb

@@ -0,0 +1,107 @@
+module Patience
+  ###
+  # Patience::Card is a card creator class. Cards have ranks and suits. Every
+  # card has its own sprite. Sprite is a one big image, which contains every
+  # play card in the game. A sprite for a card is chosen by shift on the sprite.
+  # The shift is determined by integer values on X and Y axis repsectively.
+  #   card = Card.new(13, 3)
+  #   card.to_s #=> "Ace of Spades"
+  #   card.face_down
+  #   card.face_up? #=> false
+  #
+  class Card
+    extend Forwardable
+
+    attr_reader :rank, :suit, :sprite
+
+    # Creates new card object. Both arguments should be Fixnums
+    # in the valid ranges. Also, every card has its sprite, which
+    # is nothing but an instance of the Ray::Sprite class.
+    def initialize(rank, suit)
+      @rank = case rank
+                when 1  then Rank::Ace.new
+                when 2  then Rank::Two.new
+                when 3  then Rank::Three.new
+                when 4  then Rank::Four.new
+                when 5  then Rank::Five.new
+                when 6  then Rank::Six.new
+                when 7  then Rank::Seven.new
+                when 8  then Rank::Eight.new
+                when 9  then Rank::Nine.new
+                when 10 then Rank::Ten.new
+                when 11 then Rank::Jack.new
+                when 12 then Rank::Queen.new
+                when 13 then Rank::King.new
+              else
+                raise DefunctRank, "Nonexistent rank: #{rank}"
+              end
+      @suit = case suit
+                when 1 then Suit::Heart.new
+                when 2 then Suit::Diamond.new
+                when 3 then Suit::Spade.new
+                when 4 then Suit::Club.new
+              else
+                raise DefunctSuit, "Nonexistent suit: #{suit}"
+              end
+      @sprite = Ray::Sprite.new path_of('patience/sprites/card_deck.png')
+      # A sheet with 14 columns and 5 rows. First row and column
+      # corresponds to the card back (their coordinats are equal to [0, 0]).
+      @sprite.sheet_size = [14, 5]
+      @sprite.sheet_pos = [rank, suit]
+    end
+
+    # Prints human readable rank and suit of the card.
+    def to_s
+      "#{rank} of #{suit}"
+    end
+
+    # Turns the card to its face.
+    def face_up
+      sprite.sheet_pos = [rank.to_i, suit.to_i]
+    end
+
+    # The opposite of the Card#face_down? method. Returns true
+    # if the card is turned to its face. Otherwise, returns false.
+    def face_up?
+      self.not.face_down?
+    end
+
+    # Turns the card to its back (sets position of the sprite to zero values).
+    def face_down
+      sprite.sheet_pos = [0, 0]
+    end
+
+    # Returns true if the card is turned to its back (it means, that the
+    # sprite of the card is set position of zero). Otherwise, returns false.
+    def face_down?
+      sprite.sheet_pos == [0, 0]
+    end
+
+    # Either turns the card to its face if it's faced
+    # down or turns it to its back if it's faced up.
+    def flip!
+      (face_up if face_down?) or (face_down if face_up?)
+    end
+
+    # Draws the sprite of card in the window.
+    def draw_on(win)
+      win.draw(sprite)
+    end
+
+    # Compares two cards with each other,
+    # considering their rank and suit equality.
+    def eql?(other_card)
+      (@rank == other_card.rank) and (@suit == other_card.suit)
+    end
+
+    def overlaps?(other_card)
+      sprite.collide?(other_card.sprite) and self.not.eql?(other_card)
+    end
+
+    def_delegators :@sprite, :pos, :pos=, :x, :y, :to_rect
+    def_delegator  :"@sprite.to_rect", :contain?, :hit?
+
+    class DefunctRank < StandardError; end
+    class DefunctSuit < StandardError; end
+  end
+end

data/lib/patience/core_ext/class.rb

@@ -0,0 +1,17 @@
+require_relative 'core_ext'
+
+class Class
+  rake_extension("descendants") do
+
+    # Returns the array of all descendants of a class. Although there is
+    # faster way to do this, I want to stick with this solutions, since
+    # it's much simpler to understand and performance isn't crucial for now.
+    #
+    # The example of faster implementation lives in:
+    # rails/activesupport/lib/active_support/descendants_tracker.rb
+    def descendants
+      ObjectSpace.each_object(::Class).select {|klass| klass < self }
+    end
+
+  end
+end

data/lib/patience/core_ext/core_ext.rb

@@ -0,0 +1 @@
+require 'rake'

data/lib/patience/core_ext/object.rb

@@ -0,0 +1,37 @@
+require_relative 'core_ext'
+
+class Object
+  rake_extension("not") do
+    def not
+      Not.new(self)
+    end
+  end
+
+  ###
+  # The original idea belongs to Jay Fields:
+  # http://blog.jayfields.com/2007/08/ruby-adding-not-method-for-readability.html
+  #
+  # The Object::Not instances are proxies, that send all calls back to the
+  # original instance. The Object::Not class privatizes almost all of its
+  # methods so that most method calls will be handled by method_missing.
+  class Not
+    private *instance_methods.select { |m| m !~ /(^__|^\W|^binding$)/ }
+
+    rake_extension("initialize") do
+      def initialize(subject)
+        @subject = subject
+      end
+    end
+
+    rake_extension("method_missing") do
+
+      # Forwards on any method call to the subject and negates the result.
+      def method_missing(sym, *args, &block)
+        !@subject.send(sym, *args, &block)
+      end
+
+    end
+
+  end
+
+end

data/lib/patience/core_ext/string.rb

@@ -0,0 +1,33 @@
+require_relative 'core_ext'
+
+class String
+  rake_extension("demodulize") do
+
+    # Removes the module part from the
+    # constant expression in the string.
+    def demodulize
+      self.to_s.gsub(/^.*::/, '')
+    end
+
+  end
+
+  rake_extension("constantize") do
+
+    # Constantize tries to find a declared constant with the name specified
+    # in the string. It raises a NameError when the name is not in CamelCase
+    # or is not initialized.
+    # Example:
+    #   "Module".constantize #=> Module
+    #   "Class".constantize  #=> Class
+    #   "yadda".constantize  #=> NameError: yadda is not a valid constant name!
+    #
+    def constantize
+      unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self
+        raise NameError, "#{self.inspect} is not a valid constant name!"
+      end
+
+      Object.module_eval("::#{$1}", __FILE__, __LINE__)
+    end
+
+  end
+end