Soleone-cards 0.0.3

data/README.textile

@@ -0,0 +1,27 @@
+h1. Cards (temporary name)
+
+Cards wants to be a framework for building card games like Magic: The Gathering.
+
+h2. User Guide
+
+A @Card@ can have a @name@, @type@, @description@, a subclass is @Creature@ (something to "put on the table").
+You can inherit from the @Creature@ model to create monsters and people, etc.
+
+Creatures include the @Fighting@ module, which gives them @power@, @defense@ and @health@
+They can attack another creature and deal damage according to their power.
+If a creature has 3 power and the other one 1 defense, then the other creature will loose 2 health.
+
+*TODO*
+
+
+h2. TODO
+
+These things need to be done:
+
+# -Summon Creatures-
+# -Creatures can fight each other-
+# -Creatures stay until killed-
+# Rewrite MetaClass implementation (use class instance variable @attributes instead of @@attributes for easy value inheritance)
+# Enchant creatures with temporary or permanent "spells"
+# "Cast spells" that do something only once (like 2 damage to player)
+# Try to be theme-agnostic could be either fantasy, science fiction or even reality-like

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 0
+:patch: 3

data/lib/cards.rb

@@ -0,0 +1,4 @@
+lib = %w[lib/meta_class behavior/fighting behavior/effects behavior/abilities card creatures/creature creatures/human creatures/animal]
+lib.each do |file|
+  require File.dirname(__FILE__) + "/cards/#{file}.rb"
+end

data/lib/cards/behavior/abilities.rb

@@ -0,0 +1,69 @@
+module Cards
+  module Behavior
+    module Abilities
+      def self.included(base)
+        base.send(:include, MetaClass)
+        base.class_eval do
+          define_method(:abilities) do
+            @abilities ||= AbilityArray.new(self)
+          end
+        end
+      end
+      
+      # for convenience (use all abilities at once)
+      class AbilityArray < Array
+        def initialize(creature)
+          @creature = creature
+        end
+        
+        def use
+          each { |ab| ab.use(@creature) }
+        end
+      end
+      
+      
+      class Ability
+        attr_reader :name, :description, :action
+        
+        def initialize(name, description, action=nil)
+          @name, @description, @action = name, description, action
+          deactivate!
+        end
+        
+        def use(creature)
+          @action.call(creature) unless active?
+          activate!
+        end
+        
+        def text
+          "#{name} - #{description}"
+        end
+        
+        def activate!
+          @active = true
+        end
+        
+        def deactivate!
+          @active = false
+        end
+        
+        def active?; @active; end
+      end
+      
+      # An ability that temporarily changes stats by putting effects on the creature
+      class AttributeAbility < Ability
+        def initialize(attribute, modifier, name=nil, description=nil)
+          super(name, description)
+          @action = lambda do |creature|
+            creature.effects << Cards::Behavior::Effects::Effect.new(attribute, modifier)
+            creature.effects.activate!
+          end
+        end
+        
+        def text
+          string = (modifier >= 0 ? "In" : "De") + "creases #{attribute} by #{modifier.abs}"
+        end
+      end
+    end
+  end
+end

data/lib/cards/behavior/effects.rb

@@ -0,0 +1,56 @@
+module Cards
+  module Behavior
+    module Effects
+      def self.included(base)
+        base.send(:include, MetaClass)
+          base.class_eval do
+            define_method(:effects) do
+              @effects ||= EffectArray.new(self)
+            end
+          end
+        end
+
+      # for convenience (de/activate all effects at once)
+      class EffectArray < Array
+        def initialize(creature)
+          @creature = creature
+        end
+        
+        def activate!
+          each { |effect| effect.activate!(@creature) }
+        end
+        
+        def deactivate!
+          each { |effect| effect.deactivate!(@creature) }
+        end
+      end
+      
+      
+      class Effect
+        attr_reader :attribute, :modifier
+
+        # Example: Effect.new(:power, -2)
+        # Decreases the power of the affected creature temporarily by 2
+        def initialize(attribute, modifier, temporary=true)
+          @attribute, @modifier, @temporary = attribute, modifier, temporary
+          @active = false
+        end
+        
+        def temporary?; @temporary; end
+        
+        def activate!(creature)
+          creature.send("#{@attribute}!", @modifier) unless active?
+          @active = true
+        end
+        
+        def deactivate!(creature)
+          creature.send("#{@attribute}!", -@modifier) if active?
+          @active = false
+        end
+        
+        def active?; @active ;end
+      end
+      
+    end
+  end
+end

data/lib/cards/behavior/fighting.rb

@@ -0,0 +1,108 @@
+module Cards
+  module Behavior
+    module Fighting
+      def self.included(base)
+        base.send(:include, MetaClass)
+        base.instance_eval do
+          attributes :power, :defense, :health
+
+          power 0
+          defense 1
+          health 1
+        end
+      end
+      
+      # Saves details of a hit from one creature to another
+      class Hit
+        attr_reader :source, :target
+        
+        def initialize(source, target, options={})
+          @source, @target, @options = source, target, options
+        end
+        
+        def power
+          @power ||= @source.power
+        end
+        
+        def double!
+          @power = power * 2
+        end
+        
+        def apply
+          double! if @options[:double]
+          @target.health -= impact
+          @applied = true
+          self
+        end
+        
+        def applied?
+          @applied || false
+        end
+        
+        # damage after defense modifier
+        def impact
+          power > 0 ? power - @target.defense : 0
+        end
+      end
+      
+      # instance methods
+      # ================
+      
+      # try to attack another creature
+      # TODO: could later be used to only hit if not blocked, deflected or similar.
+      #       Creatures could also have different chances to hit in an additional attribute (more complex rules though)
+      def attack(creature, options={})
+        creature.take_hit(self, options)
+      end
+      
+      # the creature gets hit
+      def take_hit(from, options={})
+        @hits ||= []
+        hit = Hit.new(from, self, options)
+        @hits << hit.apply
+        event(:hit, hit)        
+      end
+      
+      # all the hits this creature has endured
+      # TODO: could later be used for bonuses or special abilities for example
+      def hits
+        @hits || []
+      end
+      
+      def killed?
+        kill! if health <= 0
+        @killed 
+      end
+      
+      def kill!
+        return if @killed
+        health = 0
+        event(:killed)
+        @killed = true
+      end
+      
+    protected
+      # overwrite this in subclasses to react on incoming hits
+      def hit_taken(hit)
+        puts "#{type} has been hit for #{hit.impact}"
+      end
+
+      # overwrite this in subclasses to react when the creature dies
+      def killed
+        puts "#{type} has been killed"
+      end
+      
+    private
+      def event(name, *args)
+        case name
+        when :hit
+          self.hit_taken(args.first)
+          self.killed?
+        when :killed
+          self.killed
+        end
+      end
+            
+    end
+  end
+end

data/lib/cards/card.rb

@@ -0,0 +1,10 @@
+module Cards
+  class Card
+    include MetaClass
+    attributes :title, :type, :text, :description
+    
+    def type
+      self.class.name.split("::").last
+    end
+  end
+end

data/lib/cards/creatures/animal.rb

@@ -0,0 +1,21 @@
+module Cards
+  module Creatures
+
+    # Base animal
+    class Animal < Creature
+      title "Animal"
+      description "Animals come in all sorts of flavors. They can be tiny and sneaky or big and powerful."
+    end
+    
+    # List actual animals
+    class Rhino < Animal
+      title "Rhino"
+      description "Huge Rhinos can have enormous attacking power and they have a thick armor plating as skin."
+      
+      power 3
+      defense 3
+      health 2
+    end
+    
+  end
+end

data/lib/cards/creatures/creature.rb

@@ -0,0 +1,9 @@
+module Cards
+  module Creatures
+    class Creature < Card
+      include Behavior::Fighting
+      include Behavior::Effects
+      include Behavior::Abilities
+    end
+  end
+end

data/lib/cards/creatures/human.rb

@@ -0,0 +1,10 @@
+module Cards
+  module Creatures
+    class Human < Creature
+      title "Human"
+      description "Humans are the most common species on planet Earth."
+      
+      health 2
+    end
+  end
+end

data/lib/cards/lib/meta_class.rb

@@ -0,0 +1,72 @@
+module Cards
+  module MetaClass
+
+    def self.included(base)
+      base.send(:extend, ClassMethods)      
+    end
+ 
+  private 
+    module ClassMethods
+      def metaclass
+        class << self; self; end
+      end
+  
+      def recursive_attributes
+        all_attributes = {}
+        ancestors[0..-1].each do |clazz|
+          if clazz.respond_to?(:attributes) && clazz.attributes.is_a?(Hash)
+            clazz.attributes.each do |key, value|
+              all_attributes[key] = value unless all_attributes[key]
+            end
+          end
+        end
+        all_attributes
+      end
+      
+      def all_attributes
+        @@attributes  
+      end
+      
+      def attributes(*names)
+        return @@attributes[self.name] if names.empty?
+    
+        attr_accessor *names
+        
+        names.each do |name|
+          class_eval do
+            # generates e.g.: power!(-2) # changes power by -2
+            define_method("#{name}!") do |value|
+              old = instance_variable_get("@#{name}")
+              instance_variable_set("@#{name}", old + value)
+            end
+          end
+          
+          metaclass.instance_eval do
+            define_method(name) do |value|
+              @@attributes ||= {}
+              @@attributes[self.name] ||= {}
+              @@attributes[self.name][name] = value
+            end
+            
+            define_method(:create) do |options|
+              instance = new
+              options.each do |name, value|
+                instance.instance_variable_set("@#{name}", value)
+              end
+              instance
+            end
+          end
+        end
+
+        class_eval do
+          define_method(:initialize) do
+            self.class.recursive_attributes.each do |name, value|
+              instance_variable_set("@#{name}", value)
+            end
+          end          
+        end
+      end  # end attributes
+    end
+    
+  end
+end

data/lib/cards/resource.rb

@@ -0,0 +1,10 @@
+module Cards
+  class Resource
+    include MetaClass
+    attributes :title, :type, :text, :description
+    
+    def type
+      self.class.name.split("::").last
+    end
+  end
+end

data/spec/behavior/abilities_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+include Cards::Creatures
+include Cards::Behavior::Abilities
+
+describe "Abilities" do
+  before do
+    @creature = Creature.new
+  end
+
+  context "when included in a Class should add methods:" do    
+    it { @creature.should respond_to(:abilities) }
+  end
+  
+  context "AttributeAbilities" do
+    before do
+      @rage = AttributeAbility.new(:power, +2)
+      @defense = AttributeAbility.new(:defense, +1)
+    end
+    
+    it "activate all abilities a creature has with abilities#use" do
+      @creature.abilities << @rage
+      @creature.abilities << @defense
+      @creature.abilities.each { |ab| ab.should_not be_active }
+
+      @creature.abilities.use
+      @creature.abilities.each { |ab| ab.should be_active }
+    end
+    
+    it "should activate an Effect when using the Ability" do |variable|
+      @creature.abilities << @rage
+      @creature.effects.should be_empty
+      lambda { @creature.abilities.use }.should change{@creature.power}.by(2)
+      @creature.should have(1).effects
+      @creature.effects.first.should be_active
+    end
+      
+  end
+end

data/spec/behavior/effects_spec.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+include Cards::Creatures
+
+describe "Effects" do
+  before do
+    @creature = Creature.new
+  end
+
+  context "when included in a Class should add methods:" do
+    it { @creature.should respond_to(:effects) }
+  end 
+end

data/spec/behavior/fighting_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+include Cards::Creatures
+
+describe "Fighting" do
+  before do
+    @creature = Creature.new
+  end
+
+  context "when included in a Class should add methods:" do    
+    it { @creature.should respond_to(:power) }
+    it { @creature.should respond_to(:defense) }
+    it { @creature.should respond_to(:health) }
+    
+    it { @creature.should respond_to(:attack) }
+    it { @creature.should respond_to(:take_hit) }
+
+    it { @creature.should respond_to(:hit_taken) }
+    it { @creature.should respond_to(:killed) }
+
+    it { @creature.should respond_to(:kill!) }
+    it { @creature.should respond_to(:killed?) }
+    
+  end
+  
+  context "attack" do
+    before do
+      @target = Creature.new
+      @man = Human.create(:power => 2)
+      @woman = Human.create(:power => 1, :health => 10)
+    end
+    
+    it "should create a Hit and apply it" do
+      lambda { @creature.attack(@target) }.should change { @target.hits.size }.from(0).to(1)
+      @target.hits.first.should be_applied
+    end
+    
+    it "should invoke the 'hit_taken' callback" do
+      @target.should_receive(:hit_taken)
+      @creature.attack(@target)
+    end
+    
+    it "should invoke the generic 'event' callback" do
+      @target.should_receive(:event)
+      @creature.attack(@target)
+    end
+
+    it "should lose 0 health with 1 defense when being hit with 1 power" do
+      lambda{ @woman.attack(@man) }.should_not change{@man.health}
+    end
+    
+    it "should lose 1 health with 1 defense when being hit with 2 power" do
+      lambda{ @man.attack(@woman) }.should change{@woman.health}.by(-1)
+    end
+
+    it "should lose 3 health with 1 defense when hit with 2 power and double-modifier" do
+      lambda{ @man.attack(@woman, :double => true) }.should change{@woman.health}.by(-3)
+    end
+    
+    it "should get killed when health reaches 0" do
+      @man.attack(@target)
+      @target.health.should == 0
+      @target.should be_killed
+    end
+    
+    it "should call killed event when killed for first time" do
+      @target.should_receive(:killed)
+      @target.kill!      
+    end
+    
+    it "should not call killed event when killed and already dead" do
+      @target.should_receive(:killed).once
+      @target.kill!
+      @target.kill!
+    end
+    
+  end
+  
+end

data/spec/card_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe "Card" do
+  before do
+    @card = Card.new
+  end
+  
+  it do
+    Card.ancestors.should include(MetaClass)
+  end
+  
+  context ".attr_generate" do
+    it "should respond to .title" do
+      Card.should respond_to(:title)
+    end
+    
+    it do
+      @card.should respond_to(:title)
+    end
+  end
+  
+  it "should have a attr_generated title, text and description" do
+    @card.should respond_to(:title)
+    @card.should respond_to(:text)
+    @card.should respond_to(:description)
+    Card.should respond_to(:title)
+    Card.should respond_to(:text)
+    Card.should respond_to(:description)
+  end
+  
+  it "#type should be 'Card'" do
+    @card.type.should == "Card"
+  end
+end

data/spec/creatures/creature_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe "Creature" do
+  context "when created" do
+    before do
+      @creature = Creature.new
+    end
+    
+    it "#type should be 'Creature'" do
+      @creature.type.should == "Creature"
+    end
+  
+    it "#text should be nil" do
+      @creature.text.should be_nil
+    end
+  
+    it "should have 0 power" do
+      @creature.power.should be(0) 
+    end
+
+    it "should have 1 defense" do
+      @creature.defense.should be(1) 
+    end
+    
+    it "should have 1 health" do
+      @creature.health.should be(1)
+    end
+  end
+  
+end

data/spec/creatures/human_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+include Cards::Creatures
+
+describe "Human" do
+  it "#type should be 'Human'" do
+    Human.new.type.should == "Human"
+  end
+  
+  it "#text should be nil" do
+    Human.new.text.should be_nil
+  end
+  
+  context "when created" do
+    it "should have 0 power" do
+      Human.new.power.should be(0) 
+    end
+
+    it "should have 1 defense" do
+      Human.new.defense.should be(1) 
+    end
+    
+    it "should have 2 health" do
+      Human.new.health.should be(2)
+    end    
+  end
+end

data/spec/lib/meta_class_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+include Cards
+
+class Person
+  include MetaClass
+  attributes :first_name, :last_name
+end
+
+
+describe "MetaClass" do
+  before do
+    @person = Person.new
+  end
+  
+  context "when included" do
+    it "should add a class method called create_attribute to class" do
+      lambda do
+        class A
+          include MetaClass
+          attributes :name
+        end
+      end.should_not raise_error(NoMethodError)
+    end
+  end
+
+  context ".attributes <name>" do
+    it "should generate a class method called <name>" do
+      Person.should respond_to(:first_name)
+    end
+
+    it "should generate a getter for <name>" do
+      @person.should respond_to(:first_name)
+    end
+    
+    it "should generate a setter for <name>" do
+      @person.should respond_to(:first_name=)
+    end
+
+    it "getter for <name> should return set value" do
+      @person.first_name = "Someone"
+      @person.first_name.should == "Someone"
+    end
+    
+    it "getter should return default value" do
+      class Person
+        first_name "Me"
+      end
+      Person.new.first_name.should == "Me"
+    end
+  end
+  
+  context "generated class method <name>" do
+    it "should allow Fixnum as default value for getter <name>" do
+      class Person
+        attributes :amount
+        amount 5
+      end
+      Person.new.amount.should == 5
+    end
+  
+    it "should allow Array as default value for getter <name>" do
+      class Person
+        attributes :stuff
+        stuff [1,2,3]
+      end
+      Person.new.stuff.should == [1,2,3]
+    end
+
+    it "should allow Hash as default value for getter <name>" do
+      class Person
+        attributes :stuff
+        stuff({:asd => 1})
+      end
+      Person.new.stuff.should == {:asd => 1}
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/../lib/cards"

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: Soleone-cards
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Soleone
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-04 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Create different types of cards in any setting (fantasy, real, science-fiction) that can fight with each other.
+email: soleone@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.textile
+- VERSION.yml
+- lib/cards
+- lib/cards/behavior
+- lib/cards/behavior/abilities.rb
+- lib/cards/behavior/effects.rb
+- lib/cards/behavior/fighting.rb
+- lib/cards/card.rb
+- lib/cards/creatures
+- lib/cards/creatures/animal.rb
+- lib/cards/creatures/creature.rb
+- lib/cards/creatures/human.rb
+- lib/cards/lib
+- lib/cards/lib/meta_class.rb
+- lib/cards/resource.rb
+- lib/cards.rb
+- spec/behavior
+- spec/behavior/abilities_spec.rb
+- spec/behavior/effects_spec.rb
+- spec/behavior/fighting_spec.rb
+- spec/card_spec.rb
+- spec/creatures
+- spec/creatures/creature_spec.rb
+- spec/creatures/human_spec.rb
+- spec/lib
+- spec/lib/meta_class_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/Soleone/cards
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: "Tiny Framework for creating card based games like Magic: The Gathering."
+test_files: []
+