enjine 0.1.0

data/lib/enjine/mechanics/triggers/damage.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Triggers
+      # Which damage a damage trigger counts: `combat: true` only combat damage, `noncombat: true` only
+      # noncombat damage (CR 120.2a-b).
+      module DamageKind
+        def setup_kind(params, errors, path)
+          @combat = params.fetch("combat", false)
+          @noncombat = params.fetch("noncombat", false)
+          %w[combat noncombat].each do |key|
+            errors << "#{path}.#{key}: must be true or false" unless [true, false].include?(params.fetch(key, false))
+          end
+          errors << "#{path}: combat and noncombat can't both be true" if @combat == true && @noncombat == true
+        end
+
+        def kind_ok?(event) = !(@combat && !event.combat) && !(@noncombat && event.combat)
+        def kind_words = ("combat " if @combat) || ("noncombat " if @noncombat)
+      end
+
+      # "Whenever ~ deals combat damage to a player" / "Whenever a source you control deals noncombat damage
+      # to an opponent".
+      class DealsDamage < Trigger
+        include DamageKind
+
+        RECIPIENTS = %w[player opponent creature any].freeze
+
+        primitive :trigger, :deals_damage,
+                  description: "The subject deals damage. `combat: true` only counts combat damage, `noncombat: true` " \
+                               "only noncombat damage; `to`: player | opponent (of the source's controller) | creature " \
+                               "| any (default). Triggers once per damage event (each combat damage step is one, so " \
+                               "double strike can trigger twice).",
+                  rules: %w[510.2 603.2 603.2c 120.2a 120.2b 120.3],
+                  params: { "subject" => "\"self\" (default) or {\"each\": filter, ...}", "combat" => "true | false",
+                            "noncombat" => "true | false", "to" => RECIPIENTS.join(" | ") },
+                  example: { "deals_damage" => { "combat" => true, "to" => "player" } }
+
+        def self.keys = %w[subject combat noncombat to]
+        def event_class = Events::DamageDealt
+
+        def setup(params, errors, path)
+          setup_kind(params, errors, path)
+          @to = params.fetch("to", "any")
+          errors << "#{path}.to: must be one of #{RECIPIENTS.join(", ")}" unless RECIPIENTS.include?(@to)
+        end
+
+        def match?(engine, event, source)
+          return false unless kind_ok?(event) && recipient_ok?(engine, event.target, source)
+
+          obj = engine.state.objects[event.source] or return false
+          @subject.match?(engine, event.source, obj.controller, obj.card, source, types: engine.chars(obj).types)
+        end
+
+        def recipient_ok?(engine, ref, source)
+          index = Filters.player_index(engine, ref)
+          case @to
+          when "player" then !index.nil?
+          when "opponent" then !index.nil? && index != source["controller"]
+          when "creature" then engine.state.objects.key?(ref) && engine.chars(ref).creature?
+          else true
+          end
+        end
+
+        def to_s = "Whenever #{@subject} deals #{kind_words}damage#{" to a#{"n" if @to == "opponent"} #{@to}" unless @to == "any"}"
+      end
+
+      # "Whenever this creature is dealt damage", "Whenever enchanted creature is dealt damage", "Whenever an
+      # opponent is dealt noncombat damage" (CR 120.3, 603.2). "That creature" is the one dealt damage and
+      # "that much" the damage dealt.
+      class DealtDamage < Trigger
+        include DamageKind
+        include Batched
+
+        primitive :trigger, :dealt_damage,
+                  description: "Damage is dealt to the `subject` (a permanent: \"self\" by default, \"attached\" or " \
+                               "{\"each\": filter, ...}) or, with `player` (you | opponent | any), to a player. " \
+                               "`combat` / `noncombat`: only that damage. {\"triggering\": \"object\"} is the permanent " \
+                               "dealt damage, {\"triggering\": \"player\"} the player, {\"triggering\": \"amount\"} how " \
+                               "much. `batched: true`: \"one or more ...\" (once per damage event, CR 603.2c).",
+                  rules: %w[120.3 603.2 603.2c 120.2a 120.2b],
+                  params: { "subject" => "\"self\" (default), \"attached\" or {\"each\": filter, ...}",
+                            "player" => PLAYERS.join(" | "), "combat" => "true | false", "noncombat" => "true | false",
+                            "batched" => "true | false" },
+                  example: { "dealt_damage" => { "subject" => "self" } }
+
+        def self.keys = %w[subject player combat noncombat batched]
+        def event_class = Events::DamageDealt
+
+        def setup(params, errors, path)
+          setup_kind(params, errors, path)
+          setup_batched(params, errors, path)
+          @player = params["player"]
+          errors << "#{path}.player: must be one of #{PLAYERS.join(", ")}" unless @player.nil? || PLAYERS.include?(@player)
+          errors << "#{path}: use subject or player, not both" if @player && params.key?("subject")
+        end
+
+        def match?(engine, event, source)
+          return false unless kind_ok?(event)
+
+          index = Filters.player_index(engine, event.target)
+          return player_ok?(index, source) if index
+          return false if @player
+
+          obj = engine.state.objects[event.target] or return false
+          @subject.match?(engine, event.target, obj.controller, obj.card, source, types: engine.chars(obj).types)
+        end
+
+        def player_ok?(index, source)
+          return false unless @player
+
+          @player == "any" || (@player == "you") == (index == source["controller"])
+        end
+
+        def occurrences(engine, event, source)
+          return [] unless match?(engine, event, source)
+
+          facts = { "amount" => event.amount }
+          index = Filters.player_index(engine, event.target)
+          [index ? facts.merge("player" => index) : facts.merge("object" => event.target, "card" => engine.object(event.target).card)]
+        end
+
+        def to_s
+          who = @player ? { "you" => "you are", "opponent" => "an opponent is", "any" => "a player is" }[@player] : "#{@subject} is"
+          "Whenever #{who} dealt #{kind_words}damage"
+        end
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/triggers/dilemma.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Triggers
+      # "Whenever you face a dilemma" (CR 700.17): a player faces a dilemma whenever they
+      # choose one or more modes for a spell or ability. The engine records it when the spell or ability
+      # with chosen modes is cast, activated or put on the stack, so a cancelled cast never counts.
+      class FacesDilemma < Trigger
+        primitive :trigger, :faces_dilemma,
+                  description: "A player faces a dilemma: they chose one or more modes for a spell or ability " \
+                               "(cast, activated, or a triggered ability put on the stack). " \
+                               "`controller`: you (default) | opponent | any. CR 700.17.",
+                  rules: %w[700.17 700.2 601.2b 603.3c],
+                  params: { "controller" => "you | opponent | any" },
+                  example: { "faces_dilemma" => {} }
+
+        CONTROLLERS = %w[you opponent any].freeze
+
+        def self.keys = %w[controller]
+        def event_class = Events::DilemmaFaced
+
+        def setup(params, errors, path)
+          @controller = params.fetch("controller", "you")
+          errors << "#{path}.controller: must be one of #{CONTROLLERS.join(", ")}" unless CONTROLLERS.include?(@controller)
+        end
+
+        def match?(engine, event, source)
+          who = engine.names.index(event.player)
+          @controller == "any" || (@controller == "you") == (who == source["controller"])
+        end
+
+        def to_s = "Whenever #{{ "you" => "you face", "opponent" => "an opponent faces" }.fetch(@controller, "a player faces")} a dilemma"
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/triggers/draw_and_discard.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Triggers
+      # "Whenever you draw a card" (CR 121.2): once for each card drawn.
+      class Draws < PlayerTrigger
+        primitive :trigger, :draws,
+                  description: "A player draws a card; triggers once per card (draws happen one at a time). " \
+                               "`controller`: you (default) | opponent | any.",
+                  rules: %w[121.1 121.2],
+                  params: { "controller" => PLAYERS.join(" | ") },
+                  example: { "draws" => { "controller" => "you" } }
+
+        def event_class = Events::ZoneChanged
+
+        def match?(engine, event, source)
+          event.from == "library" && event.to == "hand" && event.reason == "draw" && player_ok?(engine, event.owner, source)
+        end
+
+        def to_s = "Whenever #{who} draw#{"s" unless @controller == "you"} a card"
+      end
+
+      # "Whenever you discard a card" / "one or more cards" (CR 701.9a). A cycled card is discarded too
+      # (CR 702.29d).
+      class Discards < PlayerTrigger
+        include Batched
+        include CardMatch
+
+        primitive :trigger, :discards,
+                  description: "A player (`controller`: you (default) | opponent | any) discards a card (optional `card` " \
+                               "filter). `batched: true`: \"one or more cards\", once per event batch; then \"that many\" " \
+                               "is how many were discarded.",
+                  rules: %w[701.9a 603.2c 702.29d],
+                  params: { "controller" => PLAYERS.join(" | "), "card" => "card filter", "batched" => "true | false" },
+                  example: { "discards" => { "controller" => "you", "batched" => true } }
+
+        def self.keys = %w[controller card batched]
+        def event_class = Events::ZoneChanged
+
+        def setup(params, errors, path)
+          super
+          setup_batched(params, errors, path)
+          setup_card(params, errors, path)
+        end
+
+        def match?(engine, event, source)
+          event.reason == "discard" && event.from == "hand" && player_ok?(engine, event.owner, source) && card_ok?(engine, event.card)
+        end
+
+        def to_s
+          "Whenever #{who} discard#{"s" unless @controller == "you"} #{@batched ? "one or more #{card_words}s" : "a #{card_words}"}"
+        end
+      end
+
+      # "Whenever you cycle a card" (CR 702.29a): a player activates a cycling (or typecycling) ability.
+      class Cycles < PlayerTrigger
+        include CardMatch
+
+        primitive :trigger, :cycles,
+                  description: "A player (`controller`: you (default) | opponent | any) cycles a card (activates its " \
+                               "cycling or typecycling ability; optional `card` filter).",
+                  rules: %w[702.29a 702.29e],
+                  params: { "controller" => PLAYERS.join(" | "), "card" => "card filter" },
+                  example: { "cycles" => { "controller" => "you" } }
+
+        def self.keys = %w[controller card]
+        def event_class = Events::AbilityActivated
+
+        def setup(params, errors, path)
+          super
+          setup_card(params, errors, path)
+        end
+
+        def match?(engine, event, source)
+          ability = engine.catalog.fetch(event.card).ability(event.ability)
+          ability.respond_to?(:cycling?) && ability.cycling? && player_ok?(engine, event.player, source) &&
+            card_ok?(engine, event.card)
+        end
+
+        def to_s = "Whenever #{who} cycle#{"s" unless @controller == "you"} a #{card_words}"
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/triggers/keyword_actions.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Triggers
+      # "Whenever you scry" / "Whenever you surveil" (CR 701.22, 701.25): once the whole action is done
+      # (CR 701.25d); scry 0 / surveil 0 isn't one (CR 701.22b, 701.25c). "Whenever you scry or surveil" is
+      # `any_of` both.
+      class KeywordActionTrigger < PlayerTrigger
+        def event_class = Events::KeywordAction
+        def match?(engine, event, source) = event.action == self.class.action && player_ok?(engine, event.player, source)
+        def to_s = "Whenever #{who} #{self.class.action}#{"s" unless @controller == "you"}"
+      end
+
+      # "Whenever you scry".
+      class Scries < KeywordActionTrigger
+        primitive :trigger, :scries,
+                  description: "A player (`controller`: you (default) | opponent | any) scries (not scry 0). Triggers " \
+                               "after the scry is complete.",
+                  rules: %w[701.22a 701.22b],
+                  params: { "controller" => PLAYERS.join(" | ") },
+                  example: { "any_of" => [{ "scries" => {} }, { "surveils" => {} }] }
+
+        def self.action = "scry"
+      end
+
+      # "Whenever you surveil".
+      class Surveils < KeywordActionTrigger
+        primitive :trigger, :surveils,
+                  description: "A player (`controller`: you (default) | opponent | any) surveils (not surveil 0). " \
+                               "Triggers after the surveil is complete.",
+                  rules: %w[701.25a 701.25c 701.25d],
+                  params: { "controller" => PLAYERS.join(" | ") },
+                  example: { "surveils" => { "controller" => "you" } }
+
+        def self.action = "surveil"
+      end
+
+      # "Whenever you earthbend / waterbend / airbend / firebend" (CR 701.66b, 701.67c, 701.65b, 702.189b): the
+      # bending happened (the earthbend delayed trigger was created, a waterbend cost was paid, objects were
+      # exiled by an airbend, a firebending ability resolved). "Whenever you waterbend, earthbend, firebend, or
+      # airbend" is `any_of` the four.
+      {
+        earthbends: ["earthbend", %w[701.66b]], waterbends: ["waterbend", %w[701.67c]],
+        airbends: ["airbend", %w[701.65b]], firebends: ["firebend", %w[702.189b]]
+      }.each do |name, (verb, rules)|
+        klass = Class.new(KeywordActionTrigger) { define_singleton_method(:action) { verb } }
+        Triggers.const_set(name.to_s.capitalize, klass)
+        klass.primitive :trigger, name,
+                        description: "A player (`controller`: you (default) | opponent | any) #{verb}s.",
+                        rules: rules, params: { "controller" => PLAYERS.join(" | ") }, example: { name.to_s => {} }
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/triggers/life.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Triggers
+      # "Whenever you gain life" (CR 119.9): once per life gain event; gaining 0 life isn't one.
+      class GainsLife < PlayerTrigger
+        primitive :trigger, :gains_life,
+                  description: "A player gains life (once per life gain event; lifelink combat damage is one event " \
+                               "per source). `controller`: you (default) | opponent | any.",
+                  rules: %w[119.9 120.3f],
+                  params: { "controller" => PLAYERS.join(" | ") },
+                  example: { "gains_life" => { "controller" => "you" } }
+
+        def event_class = Events::LifeChanged
+        def match?(engine, event, source) = event.gain.positive? && player_ok?(engine, event.player, source)
+        def to_s = "Whenever #{who} gain#{"s" unless @controller == "you"} life"
+      end
+
+      # "Whenever an opponent loses life".
+      class LosesLife < PlayerTrigger
+        primitive :trigger, :loses_life,
+                  description: "A player loses life (damage to a player is life loss, CR 120.3a). " \
+                               "`controller`: you (default) | opponent | any.",
+                  rules: %w[119.3 120.3a],
+                  params: { "controller" => PLAYERS.join(" | ") },
+                  example: { "loses_life" => { "controller" => "opponent" } }
+
+        def event_class = Events::LifeChanged
+        def match?(engine, event, source) = event.loss.positive? && player_ok?(engine, event.player, source)
+        def to_s = "Whenever #{who} lose#{"s" unless @controller == "you"} life"
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/triggers/steps.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Triggers
+      # "At the beginning of your upkeep" / "... of each end step".
+      class StepBegins < Trigger
+        STEPS = %w[untap upkeep draw precombat_main beginning_of_combat declare_attackers declare_blockers
+                   combat_damage end_of_combat postcombat_main end cleanup].freeze
+        WHOSE = %w[your each opponent].freeze
+
+        primitive :trigger, :step_begins,
+                  description: "A step begins. `whose`: \"your\" (default), \"each\" or \"opponent\".",
+                  rules: %w[603.6b 503.1a 513.1a],
+                  params: { "step" => "upkeep | draw | precombat_main | end | ...", "whose" => WHOSE.join(" | ") },
+                  example: { "step_begins" => { "step" => "upkeep", "whose" => "your" } }
+
+        def self.keys = %w[step whose]
+        def event_class = Events::StepBegan
+
+        def setup(params, errors, path)
+          @step = params["step"]
+          @whose = params.fetch("whose", "your")
+          errors << "#{path}.step: must be one of #{STEPS.join(", ")}" unless STEPS.include?(@step)
+          errors << "#{path}.whose: must be one of #{WHOSE.join(", ")}" unless WHOSE.include?(@whose)
+        end
+
+        def match?(engine, event, source)
+          return false unless event.step == @step
+
+          active = engine.state.active
+          @whose == "each" || (@whose == "your") == (active == source["controller"])
+        end
+
+        def to_s = "At the beginning of #{@whose == "each" ? "each" : @whose} #{@step.tr("_", " ")}"
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/triggers/tap_and_counters.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Triggers
+      # "Whenever ~ becomes untapped" (CR 603.2e): not a permanent that enters untapped.
+      class BecomesUntapped < Trigger
+        primitive :trigger, :becomes_untapped,
+                  description: "The subject becomes untapped (in the untap step or by an effect). A permanent that " \
+                               "enters untapped doesn't become untapped.",
+                  rules: %w[603.2e 701.26b],
+                  params: { "subject" => "\"self\" (default), \"attached\" or {\"each\": filter, ...}" },
+                  example: { "becomes_untapped" => { "subject" => "attached" } }
+
+        def event_class = Events::Untapped
+
+        def match?(engine, event, source)
+          obj = engine.state.objects[event.object] or return false
+          @subject.match?(engine, event.object, obj.controller, obj.card, source, types: engine.chars(obj).types)
+        end
+
+        def to_s = "Whenever #{@subject} becomes untapped"
+      end
+
+      # "Whenever ~ becomes tapped" (CR 603.2e): only a permanent already on the battlefield changing from
+      # untapped to tapped; entering tapped isn't becoming tapped. `for: "teamwork"`: "becomes tapped to pay a
+      # teamwork cost" (CR 702.194a), known once the spell is cast.
+      class BecomesTapped < Trigger
+        COSTS = %w[teamwork].freeze
+
+        primitive :trigger, :becomes_tapped,
+                  description: "The subject becomes tapped (for any reason: a cost, attacking, an effect). A " \
+                               "permanent that enters tapped doesn't become tapped. `for: \"teamwork\"`: only when " \
+                               "it's tapped to pay a teamwork cost (it triggers once the spell is cast).",
+                  rules: %w[603.2e 701.26a 702.194a],
+                  params: { "subject" => "\"self\" (default) or {\"each\": filter, ...}", "for" => COSTS.join(" | ") },
+                  example: { "becomes_tapped" => { "subject" => "self" } }
+
+        def self.keys = %w[subject for]
+        def event_class = @for ? Events::TappedForCost : Events::Tapped
+
+        def setup(params, errors, path)
+          @for = params["for"]
+          errors << "#{path}.for: must be one of #{COSTS.join(", ")}" unless @for.nil? || COSTS.include?(@for)
+        end
+
+        def match?(engine, event, source)
+          obj = engine.state.objects[event.object] or return false
+          @subject.match?(engine, event.object, obj.controller, obj.card, source, types: engine.chars(obj).types)
+        end
+
+        def to_s = "Whenever #{@subject} becomes tapped#{" to pay a #{@for} cost" if @for}"
+      end
+
+      # "Whenever one or more [kind] counters are put on ~" (CR 122.6): counters put on a permanent, including
+      # the counters it enters with. Once per counter-placing event.
+      class CountersPlaced < Trigger
+        primitive :trigger, :counters_placed,
+                  description: "One or more counters (only `counter`, if given) are put on the subject, including the " \
+                               "counters it enters the battlefield with. Triggers once per event, however many counters.",
+                  rules: %w[122.6 603.2 603.2c],
+                  params: { "subject" => "\"self\" (default) or {\"each\": filter, ...}", "counter" => "counter name",
+                            "first_time_this_turn" => "true: only the first time each turn such counters are put on " \
+                                                      "that permanent (an earlier placement counts even if nothing " \
+                                                      "could trigger then)" },
+                  example: { "counters_placed" => { "counter" => "+1/+1" } }
+
+        def self.keys = %w[subject counter first_time_this_turn]
+        def watches?(event) = event.is_a?(Events::CountersChanged) || event.is_a?(Events::ZoneChanged)
+
+        def setup(params, errors, path)
+          @counter = params["counter"] && Counters.parse(params["counter"], errors, "#{path}.counter")
+          @first_time = params["first_time_this_turn"]
+          errors << "#{path}.first_time_this_turn: must be true or false" unless [nil, true, false].include?(@first_time)
+        end
+
+        def occurrences(engine, event, source)
+          id, amount = placed(engine, event)
+          return [] unless amount&.positive?
+          return [] if @first_time && engine.counter_placements_this_turn(id, @counter) != 1
+
+          obj = engine.object(id)
+          return [] unless @subject.match?(engine, id, obj.controller, obj.card, source, types: engine.chars(obj).types)
+
+          [{ "object" => id, "player" => obj.controller, "amount" => amount, "card" => obj.card }]
+        end
+
+        def match?(engine, event, source) = !occurrences(engine, event, source).empty?
+
+        def to_s
+          first = " for the first time each turn" if @first_time
+          "Whenever one or more #{"#{@counter} " if @counter}counters are put on #{@subject}#{first}"
+        end
+
+        private
+
+        # [object id, how many matching counters were put on it] for this event, or nil.
+        def placed(engine, event)
+          if event.is_a?(Events::CountersChanged)
+            return nil if @counter && event.counter != @counter
+
+            [event.object, event.to - event.from]
+          elsif event.to == "battlefield" && (obj = engine.state.objects[event.new_id])
+            counts = @counter ? [obj.counters.fetch(@counter, 0)] : obj.counters.values
+            [obj.id, counts.sum]
+          end
+        end
+      end
+    end
+  end
+end