feat: complete conditional logic implementation

- Add aura method for conditional trigger contexts
- Update glow! to support operator parsing (>=, ==, etc)
- Enable nested conditionals via stacks/charges with blocks
- Pass parent node context to triggers for glow! forwarding
- Clean up commented code in examples

Author: fx

public/examples/mage/frost.rb

@@ -16,16 +16,11 @@
           glow!
         end
       end
-      # charges '>= 2' do
-      #   glow!
-      # end
     end
-    # glow if cryopathy stacks >= 10?
-    # 
   end
 
   icon 'Ring of Fire' do
-    action_usable! do
+    action_usable!
   end
 
   action_usable 'Comet Storm'

public/examples/warrior/arms.rb

@@ -36,21 +36,9 @@
   end
   action_usable 'Bladestorm'
   action_usable 'Wrecking Throw'
-  # TODO: cleave instead of MS display when more than N targets?
   action_usable 'Cleave'
-  # action_usable 'Whirlwind'
-
-  # TODO: add `stacks` to glow! instead
-  # Min-maxing OP>MS is not recommended.
-  # action_usable 'Mortal Strike', if_stacks: { 'Overpower' => 2 } do
-  #   glow!
-  # end
-  # action_usable 'Overpower' do
-  #   glow! charges: 2
-  # end
 
   action_usable ['Mortal Strike', 'Overpower']
-  # action_usable 'Thunder Clap', requires: { target_debuffs_missing: ['Rend'] }
   action_usable 'Rend', requires: { target_debuffs_missing: ['Rend'] }
   action_usable 'Sweeping Strikes'
 end

public/node.rb

@@ -215,15 +215,16 @@ def glow!(options = {}) # rubocop:disable Metrics/MethodLength
     end
 
     if options[:charges]
+      charges_value, charges_op = parse_operator(options[:charges])
       check = {
         "variable": 'charges',
-        "op": '==',
-        "value": options[:charges].to_s,
+        "op": charges_op,
+        "value": charges_value.to_s,
         "trigger": 1
       }
     end
 
-    @conditions ||= {}
+    @conditions ||= []
     @conditions << {
       check: check,
       changes: [
@@ -235,8 +236,28 @@ def glow!(options = {}) # rubocop:disable Metrics/MethodLength
     }
   end
 
+  def aura(name, **options, &block)
+    # Add an aura trigger for conditional logic
+    options[:parent_node] = self
+    trigger = Trigger::Auras.new(aura_names: name, **options)
+    triggers << trigger
+    
+    # Execute block in context of trigger for nested conditions  
+    trigger.instance_eval(&block) if block_given?
+    trigger
+  end
+
+  def parse_operator(value)
+    return [value, '=='] if value.is_a?(Integer)
+    
+    value_str = value.to_s
+    operator = value_str.match(/^[<>!=]+/)&.[](0) || '=='
+    parsed_value = value_str.gsub(/^[<>!=]+\s*/, '').to_i
+    [parsed_value, operator]
+  end
+
   def hide_ooc! # rubocop:disable Metrics/MethodLength
-    @conditions ||= {}
+    @conditions ||= []
     @conditions << {
       check: {
         trigger: -1,

public/weak_aura/icon.rb

@@ -7,9 +7,10 @@ def all_triggers!
     end
 
     def action_usable!(**kwargs, &block)
-      kwargs = { spell: id }.merge(kwargs)
-      triggers << Trigger::ActionUsable.new(**kwargs)
-      block.call if block_given?
+      kwargs = { spell: id, parent_node: self }.merge(kwargs)
+      trigger = Trigger::ActionUsable.new(**kwargs)
+      triggers << trigger
+      trigger.instance_eval(&block) if block_given?
     end
 
     def as_json # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity

public/weak_aura/triggers.rb

@@ -20,13 +20,30 @@ def parse_count_operator(count, default_operator = '==')
     end
 
     def charges(count_op, &block)
-      @options[:charges] = count_op 
-      block.call if block_given?
+      @options[:charges] = count_op
+      
+      # Create a context for conditional logic
+      if block_given?
+        # Store the parent node context for glow! to work
+        @parent_node = @options[:parent_node] if @options[:parent_node]
+        instance_eval(&block)
+      end
     end
 
     def stacks(count_op, &block)
-      @options[:stacks] = count_op 
-      block.call if block_given?
+      @options[:stacks] = count_op
+      
+      # Create a context for conditional logic
+      if block_given?
+        # Store the parent node context for glow! to work
+        @parent_node = @options[:parent_node] if @options[:parent_node]
+        instance_eval(&block)
+      end
+    end
+    
+    def glow!(options = {})
+      # Forward glow! to parent node if available
+      @parent_node.glow!(options) if @parent_node&.respond_to?(:glow!)
     end
 
     def remaining_time(count_op, &block)