cardlike 0.0.1 → 0.1.0

data/README.md

@@ -69,7 +69,8 @@ to define your whole game in a `Cardlike.game` block.
       end
     end
 
-You can also prefix the class methods with Cardlike.
+You can also prefix the class methods with Cardlike and pass card, deck, and
+hand objects around yourself.
 
     Cardlike.type_of_card :playing_card do
       has :suit
@@ -88,7 +89,8 @@ You can also prefix the class methods with Cardlike.
 ### Creating Cards
 
 The `card` method can be used to create a new Card object. Created cards are
-stored globally and can be accessed with `the_card` and the card's name.
+stored globally and can be accessed with `the_card` and the card's name (unless
+they were created directly in a Deck).
 
     Cardlike.card "Draw one Play one" # => creates (and returns) a new Card object
     Cardlike.the_card "Draw one Play one" # => the Card object created above (NOT a copy)
@@ -100,23 +102,37 @@ to do this.
     Cardlike.type_of_card :action_card do
       has :power_level
       has :color
+      has :speed
+      has_block :activate
     end
 
     Cardlike.new_action_card "Magic Spell" do
       power_level 5
       color :red
+      speed :fast
+      activate { "zzzzZZZZAP!!" }
     end # => new Card object (actually a new ActionCard object)
 
     Cardlike.the_card("Magic Spell")[:color] # => :red
     Cardlike.the_card("Magic Spell")[:power_level] # => 5
+    Cardlike.the_card("Magic Spell").speed # => :fast (this style available after 0.0.2)
+    Cardlike.the_card("Magic Spell").activate.call # => "zzzzZZZZAP!!" (this style available after 0.0.2)
 
 The `type_of_card` method creates a new subclass of Card. Use the `has` method in
 a `card` block to add a property. A new card creation method is added to the DSL
 with the type of card prefixed by `new_`. 
 
+A `has_block` method takes a block and stores it as a property on the Card. 
+
 To assign a property to a new card in the card block, use a method of the same
 name as the property. To retrieve that property, treat the card as a hash and
-reference the property name as the key.
+reference the property name as the key. As of version 0.0.2, you can also get
+the property value by calling a getter method of the same name as the key.
+
+If you'd like to know what kind of card you're dealing with, just ask it with
+`card_type`.
+
+    Cardlike.the_card("Magic Spell").card_type # => :action_card
 
 ### Creating Decks
 
@@ -213,6 +229,16 @@ Hands can be accessed by `the_hand`, just like the other Cardlike objects.
       the_hand("Player 1").size # => 1
     end
 
+A Hand also has a few tricks up its sleve:
+
+    Cardlike.game do
+      the_hand("Player 1").remove_card_at(1) # Removes and returns the card at index 1 (0-based index)
+
+      the_hand("Player 1").remove_random_card # Removes and returns a random card from the hand.
+
+      the_hand("Player 1").remove_random_card { |card| card.name =~ /^Magic/ } # Removes and returns a random card from the cards in the hand for which the block returns true.
+    end
+
 ### Defining a Turn
 
 As most games have turns, you can define a block of code as a turn using the

data/lib/cardlike.rb

@@ -97,9 +97,7 @@ module Cardlike
   # the Card. Returns the Card (that can also be accessed with +the_card+). You
   # may use the Card DSL in the block.
   #
-  #   Cardlike.card "Fire Monster" do
-  #     text "A red-hot monster."
-  #   end
+  #   Cardlike.card "Fire Monster"
   #
   def self.card(name, &block)
     c = Card.create(name, &block)
@@ -145,8 +143,8 @@ module Cardlike
     c = Object.const_get(klass_name)
     c.class_eval(&block) if block_given?
 
-    Deck.send(:define_method, "new_#{name_underscored}", lambda { |arg, &blk| card = c.create(arg, &blk); self << card; card })
-    self.class.send(:define_method, "new_#{name_underscored}", lambda { |arg, &blk| card = c.create(arg, &blk); @cards ||= {}; @cards[arg] = card; card })
+    Deck.send(:define_method, "new_#{name_underscored}", lambda { |arg, &blk| card = c.create(arg, &blk); card.card_type = name_underscored.to_sym; self << card; card })
+    self.class.send(:define_method, "new_#{name_underscored}", lambda { |arg, &blk| card = c.create(arg, &blk); card.card_type = name_underscored.to_sym; @cards ||= {}; @cards[arg] = card; card })
 
     c
   end

data/lib/cardlike/card.rb

@@ -2,20 +2,26 @@
 # Represents a game card. Best used with the Card and Deck DSL. See Cardlike.
 #
 class Cardlike::Card
-  attr_accessor :name, :text
+  attr_accessor :name
+
+  attr_reader :card_type
 
   #
   # Create an instance of a Card. Arguments are a hash that should include
-  # +:name+ at a minimum.  Optionally all cards have a +text+ accessor that can
-  # be set in the constructor by including the option +:text+. Perhaps a better
-  # idea is to use Card.create or Cardlike.card.
+  # +:name+ at a minimum.  Perhaps a better idea is to use Card.create or
+  # Cardlike.card. Also see Cardlike.type_of_card.
   #
   def initialize(options={})
     self.name = options[:name]
-    self.text = options[:text]
+    @card_type = options[:card_type] || nil
     @properties = {}
   end
 
+  def card_type=(type)
+    raise "Cannot re-set type after it has been set." if @card_type
+    @card_type = type
+  end
+
   # 
   # Factory method to create an instance of a Card. This sets the name of the
   # card and its properties using the Card DSL in the corresponding block. You
@@ -23,9 +29,7 @@ class Cardlike::Card
   # is to create custom card types using Cardlike.type_of_card and create them
   # using the +new_+ methods.
   #
-  #   Card.create "Big Monster" do
-  #     text "Spend 1 Mana to Attack"
-  #   end
+  #   Card.create "Big Monster"
   #
   # Preferred over Card.new.
   #
@@ -35,15 +39,6 @@ class Cardlike::Card
     c
   end
 
-  # 
-  # DSL method for setting the card text. Still works as a getter if no args are
-  # passed.
-  #
-  def text(card_text=nil)
-    return @text unless card_text
-    @text = card_text
-  end
-
   # 
   # Return custom properties of this Card. Custom properties can be set using
   # the Card.has method, ideally inside a Cardlike.type_of_card block.
@@ -54,20 +49,27 @@ class Cardlike::Card
     @properties[prop]
   end
 
+  #
+  # Class DSL method for setting custom properties for a Card that include a
+  # block. See Cardlike.type_of_card.
+  #
+  def self.has_block(prop)
+    define_method(prop, lambda { |&block| return @properties[prop] unless block; raise "Cards are immutable." if @properties.has_key? prop; @properties[prop] = block })
+  end
+
   #
   # Class DSL method for setting custom properties for a Card. See
   # Cardlike.type_of_card.
   #
   def self.has(prop)
-    define_method(prop, lambda { |arg| raise "Cards are immutable." if @properties.has_key? prop; @properties[prop] = arg })
+    define_method(prop, lambda { |arg=nil| return @properties[prop] unless arg; raise "Cards are immutable." if @properties.has_key? prop; @properties[prop] = arg })
   end
 
   def to_s
     t = []
     t << "Name: #{name}"
-    t << "Text: #{text}" if text
-    @properties.each { |p,v| t << "#{p}: #{v}" } 
-    t.join("\n")
+    @properties.each { |p,v| t << "#{p}: #{v}" unless v.nil? or v.is_a? Proc } 
+    "[ "+t.join("; ")+" ]"
   end
 
 end

data/lib/cardlike/hand.rb

@@ -7,7 +7,26 @@ class Cardlike::Hand < Cardlike::Deck
   # Remove and return a Card from this hand by name.
   #
   def remove_card(card_name)
-    self.delete(self.select { |card| card.name == card_name }.first)
+    self.delete(self.find { |card| card.name == card_name })
+  end
+
+  # 
+  # Remove and return a Card from this hand at the index.
+  #
+  def remove_card_at(index)
+    self.delete_at(index)
+  end
+
+  def remove_random_card(&block)
+    if block
+      options = []
+      self.each { |c| options << c if block.call(c) }
+      c = options.sample
+      return self.delete(c)
+    else
+      c = self.sample
+      return self.delete(c)
+    end
   end
 
   #
@@ -20,9 +39,8 @@ class Cardlike::Hand < Cardlike::Deck
   end
   
   def to_s
-    puts "Hand: #{name}"
-    self.each do |card|
-      puts "-> #{card}\n"
-    end
+    cards = ["Hand: #{name}"]
+    cards += self.collect { |c| "-> #{c}" }
+    cards.join("\n")
   end
 end

data/lib/cardlike/score.rb

@@ -34,7 +34,7 @@ module Cardlike
   #
   def self.the_score(target)
     @scores ||= {}
-    @scores[target]
+    @scores[target] || 0
   end
 
   # 

data/lib/cardlike/version.rb

@@ -1,3 +1,3 @@
 module Cardlike
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/integration/card_construction_spec.rb

@@ -5,9 +5,7 @@ describe 'Defining a card' do
 
     context "for a basic card" do
       before do
-        @card = Cardlike.card "Fire Monster" do
-          text "A red-hot monster."
-        end
+        @card = Cardlike.card "Fire Monster"
       end
 
       it "creates a Card object" do
@@ -17,10 +15,6 @@ describe 'Defining a card' do
       it "properly sets the card name" do
         @card.name.should eq "Fire Monster"
       end
-
-      it "properly sets the card text" do
-        @card.text.should eq "A red-hot monster."
-      end
     end
 
   end
@@ -45,7 +39,7 @@ describe 'Defining a card' do
       @playing_card.name.should eq "PlayingCard"
     end
 
-    it "creates an accessor for the custom field" do
+    it "creates an accessor for the custom property" do
       @playing_card.new.should respond_to :suit
     end
 
@@ -64,9 +58,17 @@ describe 'Defining a card' do
         @card.should be_a_kind_of Cardlike::Card
       end
 
-      it "creates an accessor for the custom field" do
+      it "creates an accessor for the custom property" do
         @card.should respond_to :suit
       end
+
+      it "responds to the Card.card_type method with the type" do
+        @card.card_type.should eq :playing_card
+      end
+
+      it "does not allow setting of card_type" do
+        lambda { @card.card_type = 'Special Card' }.should raise_error(StandardError)
+      end
     end
     
     context "when instantiated" do
@@ -81,7 +83,7 @@ describe 'Defining a card' do
         @card.should be_a_kind_of Cardlike::Card
       end
 
-      it "creates an accessor for the custom field" do
+      it "creates an accessor for the custom property" do
         @card.should respond_to :suit
       end
 
@@ -90,11 +92,15 @@ describe 'Defining a card' do
         @card2.should_not respond_to :suit
       end
 
-      it "sets the field properly" do
+      it "sets the property properly" do
         @card[:suit].should eq 'Spades'
       end
 
-      it "does not allow fields to be set again" do
+      it "also returns the property from the accessor version of the setter" do
+        @card.suit.should eq 'Spades'
+      end
+
+      it "does not allow properties to be set again" do
         lambda { @card.suit 'Clubs' }.should raise_error(StandardError)
       end
 
@@ -102,4 +108,24 @@ describe 'Defining a card' do
 
   end
 
+  context "that includes a block" do
+    before do
+      Cardlike.game do
+        type_of_card :monster_card do
+          has_block :action
+        end
+
+        new_monster_card "Ogre" do
+          action do
+            :action_complete
+          end
+        end
+      end
+    end
+
+    it "completes the action" do
+      Cardlike.the_card("Ogre").action.call.should eq :action_complete
+    end
+  end
+
 end

data/spec/integration/dealing_spec.rb

@@ -1,42 +1,84 @@
 require 'spec_helper'
 
 describe 'A deck of cards' do
-  before do
-    @cards = []
-    @cards << Cardlike::Card.new(name: 'Leonardo', text: 'Has two swords.')
-    @cards << Cardlike::Card.new(name: 'Donatello', text: 'Has a Bo staff.')
-    @cards << Cardlike::Card.new(name: 'Michaelangelo', text: 'Has Nunchuku.')
-    @cards << Cardlike::Card.new(name: 'Raphael', text: 'Has Sai.')
-
-    @deck = Cardlike::Deck.new(name: 'Turtles', cards: @cards)
-  end
-
-  context 'when a card is drawn' do
+  context "for a simple deck" do
     before do
-      @drawn = @deck.draw
+      @cards = []
+      @cards << Cardlike::Card.new(name: 'Leonardo')
+      @cards << Cardlike::Card.new(name: 'Donatello')
+      @cards << Cardlike::Card.new(name: 'Michaelangelo')
+      @cards << Cardlike::Card.new(name: 'Raphael')
+
+      @deck = Cardlike::Deck.new(name: 'Turtles', cards: @cards)
     end
 
-    it 'is one of the cards from the deck' do
-      @cards.should include @drawn
+    context 'when a card is drawn' do
+      before do
+        @drawn = @deck.draw
+      end
+
+      it 'is one of the cards from the deck' do
+        @cards.should include @drawn
+      end
+
+      it 'is no longer in the deck' do
+        @deck.should_not include @drawn
+      end
     end
 
-    it 'is no longer in the deck' do
-      @deck.should_not include @drawn
+    context "when a card is drawn into a Hand" do
+      before do
+        @hand = Cardlike::Hand.new(name: 'Player 1')
+        @drawn = @deck.draw_into @hand
+      end
+
+      it "inserts the card into the Hand" do
+        @hand.should include @drawn
+      end
+
+      it "removes the card from the Deck" do
+        @deck.should_not include @drawn
+      end
     end
   end
 
-  context "when a card is drawn into a Hand" do
+  context "for a deck of custom cards" do
     before do
-      @hand = Cardlike::Hand.new(name: 'Player 1')
-      @drawn = @deck.draw_into @hand
-    end
+      Cardlike.game do
+        type_of_card :monster_card do
+          has :strength
+        end
 
-    it "inserts the card into the Hand" do
-      @hand.should include @drawn
+        deck "Monsters" do
+          new_monster_card("Giant Snake") { strength 5 }
+          new_monster_card("Giant Spider") { strength 3 }
+          new_monster_card("Giant Giant") { strength 8 }
+          new_monster_card("Giant Cow") { strength 2 }
+        end
+      end
     end
 
-    it "removes the card from the Deck" do
-      @deck.should_not include @drawn
+    context "when a card is drawn into a Hand" do
+      before do
+        @top_card = Cardlike.game do
+          hand "My Hand"
+          top_card = the_deck("Monsters").last
+          the_deck("Monsters").draw_into the_hand("My Hand")
+          top_card
+        end
+      end
+
+      it "removes a card from the deck" do
+        Cardlike.the_deck("Monsters").size.should eq 3
+      end
+
+      it "adds a card to the Hand" do
+        Cardlike.the_hand("My Hand").size.should eq 1
+      end
+
+      it "the drawn card is the top card from the deck" do
+        @top_card.should eq Cardlike.the_hand("My Hand").first
+      end
     end
   end
 end

data/spec/units/hand_spec.rb

@@ -19,7 +19,7 @@ describe "A hand of cards" do
       Cardlike.the_hand("Player 1").first.name.should eq "Boring Card One"
     end
 
-    context "when removing a specific card" do
+    context "when removing a card by name" do
       before do
         @card1 = Cardlike.the_hand("Player 1").remove_card "Boring Card One"
       end
@@ -33,7 +33,49 @@ describe "A hand of cards" do
       end
     end
 
-    context "when removing a card with remove_card_if" do
+    context "when removing a card at random" do
+      before do
+        @card1 = Cardlike.the_hand("Player 1").remove_random_card
+      end
+
+      it "removes a Card" do
+        @card1.should be_a_kind_of Cardlike::Card
+      end
+
+      it "removes the card from the Hand" do
+        Cardlike.the_hand("Player 1").size.should eq 3
+      end
+    end
+
+    context "when removing a card at random with specific parameters (a block)" do
+      before do
+        @card1 = Cardlike.the_hand("Player 1").remove_random_card { |c| c.name =~ /^Boring Card T/ }
+      end
+
+      it "removes a card matching the parameters" do
+        @card1.name.should satisfy { |s| ["Boring Card Two", "Boring Card Three"].include?(s) }
+      end
+
+      it "removes the card from the Hand" do
+        Cardlike.the_hand("Player 1").size.should eq 3
+      end
+    end
+
+    context "when removing a card by index" do
+      before do
+        @card1 = Cardlike.the_hand("Player 1").remove_card_at 3
+      end
+
+      it "can remove a specific card" do
+        @card1.name.should eq "Boring Card Four"
+      end
+
+      it "removes the card from the Hand" do
+        Cardlike.the_hand("Player 1").size.should eq 3
+      end
+    end
+
+    context "when removing cards with remove_card_if" do
       before do
         @card1 = Cardlike.the_hand("Player 1").remove_card_if { |c| c.name =~ /Three/ }.first
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cardlike
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-12 00:00:00.000000000 Z
+date: 2013-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec