triggerful 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd53d3d5522d0f26ab9e548d60d8293f7d8436b4
-  data.tar.gz: d12cc610d506493d41beb7af9548849ca3ea199c
+  metadata.gz: 61ac309ae45567aa35b123196c6668b619884283
+  data.tar.gz: efe1ceb742a31cc93022ce6d5c68a7390d4344be
 SHA512:
-  metadata.gz: 21bdeba842b1ad98bd72c409023bec9fbde21341606578be81a71a1cee1e56623b49c1a005e73d72b647377bef75ef5289ef0078eeaa9c956e426f9577127dbd
-  data.tar.gz: 8dbb63237849d91e9ab155ae6baae9f6073fb3dcc613494da87d813686e86b5e83c00f300aff2234f6444ae60da970dfca54b5f4e866986173dbc0a31dfc85cd
+  metadata.gz: 8725c277b0204333e982a4d2a24de50f41b4323157311ddd0bc7d4a6cb4eb4fa22e7615a4aad8df5c26fa1948b02e79d9f924d115a19551e79ffe3691645b593
+  data.tar.gz: 74119b4bb875d04155dfdd80a8cf87a94c3cce59cf5012247084d66aaaaeb41b3d127c9dd0d3c53b413d0ffdf70d48f14d2bbb617975bbb2329e098a357681d8

data/example/game-logic.rb

@@ -0,0 +1,107 @@
+# Example game logic that could be used
+require 'triggerful'
+
+class Player
+  def initialize name, power, toughness, crit
+    @name, @power, @toughness, @crit = name, power, toughness, crit
+    @health = 100
+    @gear = []
+  end
+  
+  def name(*set)
+    if set[0]
+      @name = set[0]
+    end
+    @name
+  end
+  
+  def power(*set)
+    if set[0]
+      @power += set[0]
+    end
+    @power
+  end
+  
+  def toughness(*set)
+    if set[0]
+      @toughness += set[0]
+    end
+    @toughness
+  end
+  
+  def crit(*set)
+    if set[0]
+      @crit += set[0]
+    end
+    @crit
+  end
+  
+  def health(*set)
+    if set[0]
+      @health += set[0]
+    end
+    @health
+  end
+  
+  def gear
+    @gear
+  end
+  
+  def to_s(*args)
+    puts "#{@name} health(#{@health}) power(#{@power}) toughness(#{@toughness}) crit(#{@crit}) gear(#{@gear})"
+  end
+  
+  def equip(*items)
+    @gear += items
+  end
+end
+
+# Create two players
+will = Player.new('Will', 15, 5, 20)
+fred = Player.new('Fred', 10, 10, 10)
+
+# Create an attack method (this should be attached to the Player class)
+def attack(attacker, target)
+  puts "#{attacker.name} is attacking #{target.name}."
+  if rand(0..99) < attacker.crit
+    attacker.power*2
+  else
+    attacker.power
+  end
+end
+
+# Again, this is example logic. Bad code, do not follow.
+def attacked(attacker, target, damage)
+  total_damage = damage - target.toughness
+  puts "#{target.name} has taken #{total_damage} points of damage"
+  target.health(-total_damage)
+  total_damage
+end
+
+def barbed_shield(attacker, target, legacy_damage, total_damage)
+  attacker.health(-(total_damage*0.2).floor) if target.gear.include?(:barbed_shield)
+end
+
+def display_stats(*players)
+  return_val = ""
+  players.each do |player|
+    if player.instance_of? Player
+      return_val += "{#{player.name}: health (#{player.health})} "
+    end
+  end
+  puts return_val
+end
+
+attacked_event = Trigger.new(:attacked, true, :barbed_shield, fred.public_method(:to_s), will.public_method(:to_s))
+attack_event = Trigger.new(:attack, true, attacked_event)
+
+
+# Arbitrarily equip fred with barbed_shield.
+# Also, do not use equipment like this. You should really use classes.
+fred.equip(:barbed_shield)
+
+# Fight to the death!
+while fred.health > 0 && will.health > 0 do
+  attack_event.trigger(fred, will) if fred.health > 0 && will.health > 0
+  attack_event.trigger(will, fred) if fred.health > 0 && will.health > 0
+end

data/example/methods.rb

@@ -0,0 +1,82 @@
+# A more comprehensive list of methods that Triggerful supports
+require '~/Test/triggerful/lib/triggerful.rb'
+
+$foobar = 0
+
+def foo
+  amount_of_change = rand(0..100)
+  $foobar += amount_of_change
+  
+  # The return value will be appended to the arguments sent
+  # to the callback.
+  amount_of_change
+end
+
+def say_foobar(amount_of_change)
+  puts "$foobar has increased by #{amount_of_change} and is now #{$foobar}"
+end
+
+# Set the second argument to true to append the return value
+# from the trigger to the callback.
+_foo = Trigger.new(:foo, true, :say_foobar)
+_foo.trigger
+
+# Sometimes you don't care about creating a new method the
+# normal way and you just want to use a Proc instead.
+_bar = Trigger.new(Proc.new{ $foobar += 1; 1 }, true, :say_foobar)
+_bar.trigger
+
+# You might even want to have a class's public method be
+# an event. To get a hold of that, use instance.public_method(:symbol)
+class FooBar
+  def initialize amount
+    @amount = amount
+  end
+  
+  def add
+    $foobar += @amount
+    @amount
+  end
+  
+  def subtract
+    $foobar -= @amount
+    @amount
+  end
+  
+  def amount
+    @amount
+  end
+end
+
+twenty = FooBar.new(20)
+
+# Note that FooBar.subtract has a return value, but you don't
+# need to turn progression on to use the callback.
+_twenty_add = Trigger.new(twenty.public_method(:add), true, :say_foobar)
+_twenty_subtract = Trigger.new(twenty.public_method(:add), Proc.new{ puts "$foobar has decreased by #{twenty.amount} and is now #{$foobar}" })
+
+_twenty_add.trigger
+_twenty_subtract.trigger
+
+# Triggers support a few methods that regular arrays support,
+# such as remove, delete_at, length, and index(symbol). If you
+# want an actual array of callbacks, then call Trigger.list
+_twenty_subtract.add(:foo)
+puts "(#{_twenty_subtract.length}) #{_twenty_subtract.list}\n----"
+
+_twenty_subtract.insert(1, _twenty_add)
+puts "(#{_twenty_subtract.length}) #{_twenty_subtract.list}\n----"
+
+_twenty_subtract.delete_at(0)
+puts "(#{_twenty_subtract.length}) #{_twenty_subtract.list}\n----"
+
+_twenty_subtract.delete_at(_twenty_subtract.index(:foo))
+puts "(#{_twenty_subtract.length}) #{_twenty_subtract.list}\n----"
+
+_twenty_subtract.remove_all
+puts "(#{_twenty_subtract.length}) #{_twenty_subtract.list}\n----"
+
+# If you're ever unsure of what your event is called,
+# such as when you're using a Proc, then you may call
+# the Trigger.event to fetch that data
+puts "Proc: #{_bar.event}\nSymbol: #{_foo.event}\nPublic Method: #{_twenty_add.event}"

data/example/usage.rb

@@ -0,0 +1,34 @@
+# Triggerful usage
+require 'triggerful'
+
+$foobar = 0
+
+def foo
+  $foobar += 1
+end
+
+def bar
+  puts $foobar
+end
+
+# create Trigger and callback, then trigger the Trigger
+_foo = Trigger.new(:foo, :bar)
+_foo.trigger
+
+# create a method to determine if bar has been called before
+$bar_called? = false
+def bar_called
+  $bar_called = true
+end
+
+# create a callback for the callback
+_bar = Trigger.new(:bar, :bar_called)
+
+# replace old callback with new one (note that no symbol was used for the callback)
+_foo.remove(:bar)
+_foo.add(_bar)
+
+# methods are not called when added to Trigger callbacks, only when triggered
+puts $bar_called?
+_foo.trigger
+puts $bar_called?

data/lib/triggerful.rb

@@ -1,39 +1,3 @@
-=begin
-  # USAGE:
-  
-  $foobar = 0
-  
-  def foo
-    $foobar += 1
-  end
-  
-  def bar
-    puts $foobar
-  end
-  
-  # create Trigger and callback, then trigger the Trigger
-  _foo = Trigger.new(:foo, :bar)
-  _foo.trigger
-  
-  # create a method to determine if bar has been called before
-  bar_called? = false
-  def bar_called
-    bar_called = true
-  end
-  
-  # create a callback for the callback
-  _bar = Trigger.new(:bar, :bar_called)
-  
-  # replace old callback with new one (note that no symbol was used for the callback)
-  _foo.remove(:bar)
-  _foo.add(_bar)
-  
-  # methods are not called when added to Trigger callbacks, only when triggered
-  puts bar_called?
-  _foo.trigger
-  puts bar_called?
-=end
-
 class Trigger
   def initialize event, *callbacks
     @callbacks = callbacks
@@ -51,10 +15,10 @@ class Trigger
   end
   
   def trigger(*args)
-    case @event.class.to_s
-    when 'Proc'
+    case @event
+    when Proc
       event_data = @event.call
-    when 'Method'
+    when Method
       event_data = @event.call
     else
       event_data = self.method(@event).call(*args)
@@ -67,14 +31,14 @@ class Trigger
           callback.trigger(*args)
         end
       else
-        case callback.class.to_s
-        when 'Proc'
+        case callback
+        when Proc
           if @progression
             callback.call(*args, event_data)
           else
             callback.call(*args)
           end
-        when 'Method'
+        when Method
           if @progression
             callback.call(*args, event_data)
           else
@@ -97,8 +61,10 @@ class Trigger
       if callback.instance_of? Trigger
         callback.trigger(*args)
       else
-        case callback.class.to_s
-        when 'Proc'
+        case callback
+        when Proc
+          callback.call
+        when Method
           callback.call
         else
           method(callback).call(*args)
@@ -136,13 +102,21 @@ class Trigger
     @callbacks.index(callback)
   end
   
-  def event_name
+  def event
     @event
   end
   
+  def length
+    @callbacks.length
+  end
+  
   def list
     @callbacks
   end
+  
+  def callbacks
+    @callbacks
+  end
 end
 
 =begin

metadata

@@ -1,24 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: triggerful
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Andrew Bob Garrett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-07 00:00:00.000000000 Z
+date: 2013-10-09 00:00:00.000000000 Z
 dependencies: []
-description: Create callbacks to methods that you can easily remove. Quite useful
-  for lightweight event based programming. Even the medic agrees.
-email: andrew@cocodesign.com
+description: Create callbacks to methods that you can easily and dynamically create/remove.
+  Quite useful for lightweight event based programming. Even the medic agrees.
+email: andrew@karbon.tk
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/triggerful.rb
-homepage: http://rubygems.org/gems/
+- example/usage.rb
+- example/methods.rb
+- example/game-logic.rb
+homepage: https://rubygems.org/gems/triggerful
 licenses:
 - MIT
 metadata: {}
@@ -41,5 +44,9 @@ rubyforge_project:
 rubygems_version: 2.0.6
 signing_key: 
 specification_version: 4
-summary: Triggerful is a gem used for creating modular callbacks.
-test_files: []
+summary: Triggerful is a gem used for creating modular callbacks to be used for event
+  based programming.
+test_files:
+- example/usage.rb
+- example/methods.rb
+- example/game-logic.rb