enjine 0.1.0

data/lib/enjine/mechanics/abilities/player_rules.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    # Rules that apply to a player rather than to an object (see Engine::Rules#player_rule?):
+    #   hexproof            the player can't be the target of spells or abilities opponents control (702.11c)
+    #   cant_attack         the player can't declare attackers (508.1c)
+    #   no_max_hand_size    the player has no maximum hand size (402.2, 514.1)
+    #   prevent_all_damage  all damage that would be dealt to the player is prevented (615.1)
+    #   cant_lose_for_life  the player doesn't lose the game for having 0 or less life (704.5a, 104.3b)
+    #   cant_sacrifice      the player can't sacrifice permanents matching `filter` (701.21a, 614.17b)
+    #   cant_cast           the player can't cast spells (matching `spells`) (101.2, 601.3)
+    #   cant_cast_except_from_hand  the player can't cast spells from anywhere other than their hand (601.3)
+    #   spells_cant_be_countered    spells the player controls (matching `spells`) can't be countered (101.2, 701.6a)
+    #   abilities_cant_be_countered  activated and triggered abilities the player controls can't be countered (101.2)
+    #   cant_gain_life      the player can't gain life (119.7)
+    #   cant_activate       the player can't activate abilities of sources matching `filter`, except mana
+    #                       abilities (602.5)
+    #   protection_from_opponents  the player has protection from each of their opponents: opponents' spells
+    #                       and abilities can't target them and damage from opponents' sources is prevented
+    #                       (702.16b, 702.16e, 702.16k)
+    #   damage_cant_be_prevented / combat_damage_cant_be_prevented  game rules: while any player has one, (combat)
+    #                       damage can't be prevented (615.12)
+    module PlayerRules
+      RULES = {
+        "hexproof" => %w[702.11c 115.4], "cant_attack" => %w[508.1c], "no_max_hand_size" => %w[402.2 514.1],
+        "prevent_all_damage" => %w[615.1 615.1a], "cant_lose_for_life" => %w[704.5a 104.3b],
+        "cant_sacrifice" => %w[701.21a 614.17b], "cant_cast" => %w[101.2 601.3],
+        "cant_cast_except_from_hand" => %w[101.2 601.3], "spells_cant_be_countered" => %w[101.2 701.6a],
+        "abilities_cant_be_countered" => %w[101.2 701.6a],
+        "cant_gain_life" => %w[119.7], "cant_activate" => %w[101.2 602.5],
+        "damage_cant_be_prevented" => %w[615.12], "combat_damage_cant_be_prevented" => %w[615.12],
+        "protection_from_opponents" => %w[702.16b 702.16e 702.16k]
+      }.freeze
+      # Rules that take a `filter` of permanents (required for cant_sacrifice) or a card spec of `spells`.
+      FILTERED = %w[cant_sacrifice cant_activate].freeze
+      REQUIRED_FILTER = %w[cant_sacrifice].freeze
+      SPELLS = %w[cant_cast spells_cant_be_countered].freeze
+
+      def self.rule(params, errors, path)
+        rule = Mechanics.fetch_param(params, :rule)
+        errors << "#{path}.rule: must be one of #{RULES.keys.join(", ")}" unless RULES.key?(rule)
+        rule
+      end
+
+      # [filter, spells] of a rule's data, validated for the rule.
+      def self.qualifiers(params, rule, errors, path)
+        raw = Mechanics.fetch_param(params, :filter)
+        if raw.nil? && REQUIRED_FILTER.include?(rule)
+          errors << "#{path}.filter: required"
+        elsif raw && !FILTERED.include?(rule)
+          errors << "#{path}.filter: only for #{FILTERED.join(", ")}"
+        end
+        spells = Mechanics.fetch_param(params, :spells)
+        errors << "#{path}.spells: only for #{SPELLS.join(", ")}" if spells && !SPELLS.include?(rule)
+        [raw && Mechanics.build_entry(:filter, raw, errors, "#{path}.filter"), spells && CardSpec.build(spells, errors, "#{path}.spells")]
+      end
+    end
+
+    module Abilities
+      # A static ability giving players a rule: "You don't lose the game for having 0 or less life",
+      # "You can't sacrifice Treasure tokens", "Your opponents can't attack", "Your opponents can't cast
+      # spells during your turn", "Creature spells you control can't be countered", "Players can't gain life".
+      class PlayerRule < Primitive
+        AFFECTS = %w[you opponents each].freeze
+
+        primitive :ability, :player_rule,
+                  description: "While this permanent is on the battlefield (and its `if` condition holds), `rule` " \
+                               "applies to the players in `affects` (you | opponents | each; default you). Rules: " \
+                               "#{PlayerRules::RULES.keys.join(", ")}. `cant_sacrifice` takes a `filter` of the " \
+                               "permanents that can't be sacrificed, `cant_activate` may take a `filter` of the " \
+                               "sources whose abilities can't be activated (mana abilities still can), and " \
+                               "`cant_cast` and `spells_cant_be_countered` may take a card spec of the `spells`. " \
+                               "The damage rules apply to all damage whichever players they name.",
+                  rules: PlayerRules::RULES.values.flatten.uniq + %w[604.1 604.2 611.3a],
+                  params: { "rule" => PlayerRules::RULES.keys.join(" | "), "affects" => AFFECTS.join(" | "),
+                            "filter" => "permanent filter (#{PlayerRules::FILTERED.join(", ")})",
+                            "spells" => "card spec of the spells (#{PlayerRules::SPELLS.join(", ")})",
+                            "if" => "condition (\"during your turn\": {\"your_turn\": true})" },
+                  example: { "player_rule" => { "rule" => "cant_cast", "affects" => "opponents", "if" => { "your_turn" => true } } }
+
+        attr_reader :rule, :affects, :filter, :spells, :condition
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[rule affects filter spells if], errors, path)
+          rule = PlayerRules.rule(params, errors, path)
+          affects = Mechanics.fetch_param(params, :affects) || "you"
+          errors << "#{path}.affects: must be one of #{AFFECTS.join(", ")}" unless AFFECTS.include?(affects)
+          filter, spells = PlayerRules.qualifiers(params, rule, errors, path)
+          raw_if = Mechanics.fetch_param(params, :if)
+          new(rule, affects, filter, spells: spells, condition: raw_if && Condition.build(raw_if, errors, "#{path}.if"))
+        end
+
+        def initialize(rule, affects, filter, spells: nil, condition: nil)
+          super()
+          @rule = rule
+          @affects = affects
+          @filter = filter
+          @spells = spells
+          @condition = condition
+          freeze
+        end
+
+        def kind = :player_rule
+        def mana_ability? = false
+        def allowed_types = nil
+        def try_effects = []
+
+        # Whether the rule applies to player `index` for a source controlled by `controller`.
+        def applies_to?(index, controller)
+          affects == "each" || (affects == "you") == (index == controller)
+        end
+
+        # Its "as long as" / "during your turn" condition (CR 604.2), from its source's point of view.
+        def active?(engine, source)
+          condition.nil? || condition.true?(engine, EffectContext.new(source.controller, source.id, source.id, [], []))
+        end
+
+        # Whether the object asked about (a permanent for `filter`, a card for `spells`) is one the rule is about.
+        def matches?(engine, object, source)
+          (filter.nil? || filter.match?(engine, object.id, source.controller)) && (spells.nil? || spells.match?(engine, object))
+        end
+
+        def to_s
+          who = { "you" => "you", "opponents" => "your opponents", "each" => "each player" }.fetch(affects)
+          about = filter || spells
+          "#{who}: #{rule.tr("_", " ")}#{" (#{about.is_a?(Class) ? about.primitive_name : about})" if about}" \
+            "#{" as long as #{condition}" if condition}"
+        end
+      end
+    end
+
+    module Effects
+      # "You gain hexproof until end of turn", "Prevent all damage that would be dealt to you this turn",
+      # "You have no maximum hand size until your next turn", "They can't attack this turn".
+      class PlayerRuleEffect < Effect
+        DURATIONS = %w[end_of_turn until_your_next_turn].freeze
+
+        primitive :effect, :player_rule,
+                  description: "Each referenced player (default you) gets `rule` for the `duration`: end_of_turn " \
+                               "(default) or until_your_next_turn (until the controller's next turn begins). Rules: " \
+                               "#{(PlayerRules::RULES.keys - PlayerRules::REQUIRED_FILTER).join(", ")}.",
+                  rules: PlayerRules::RULES.values.flatten.uniq + %w[611.2a 514.2],
+                  params: { "rule" => (PlayerRules::RULES.keys - PlayerRules::REQUIRED_FILTER).join(" | "), "to" => "selector",
+                            "duration" => DURATIONS.join(" | ") },
+                  example: { "player_rule" => { "rule" => "no_max_hand_size", "duration" => "until_your_next_turn" } }
+
+        attr_reader :rule, :duration
+
+        def self.keys = %w[rule duration to if]
+        def self.default_to = "you"
+
+        def setup(params, errors, path)
+          @rule = PlayerRules.rule(params, errors, path)
+          errors << "#{path}.rule: #{@rule} needs a static ability (it takes a filter)" if PlayerRules::REQUIRED_FILTER.include?(@rule)
+          @duration = Mechanics.fetch_param(params, :duration) || "end_of_turn"
+          errors << "#{path}.duration: must be one of #{DURATIONS.join(", ")}" unless DURATIONS.include?(@duration)
+        end
+
+        def apply(engine, ctx)
+          affected = players(engine, ctx).map { Filters.player_ref(engine, it) }
+          engine.add_continuous_effect!("player_rule", ctx, affected, "rule" => rule, "duration" => duration)
+        end
+
+        def to_s = "#{rule.tr("_", " ")} (#{duration.tr("_", " ")}) → #{to}"
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/abilities/replacement_effects.rb

@@ -0,0 +1,368 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    # Which permanents a static ability of a permanent applies to, relative to its controller:
+    #   {"each": filter, "controller": "you" | "opponent" | "any", "other": true}
+    class Affects
+      CONTROLLERS = %w[you opponent any].freeze
+
+      attr_reader :filter, :controller, :other
+
+      def self.build(data, errors, path)
+        unless data.is_a?(Hash) && data["each"]
+          errors << "#{path}: must be {\"each\": filter, \"controller\": you|opponent|any, \"other\": bool}"
+          return new(nil, "any", false)
+        end
+        Mechanics.check_keys(data, %w[each controller other], errors, path)
+        controller = data.fetch("controller", "any")
+        errors << "#{path}.controller: must be one of #{CONTROLLERS.join(", ")}" unless CONTROLLERS.include?(controller)
+        new(Mechanics.build_entry(:filter, data["each"], errors, "#{path}.each"), controller, data["other"] == true)
+      end
+
+      def initialize(filter, controller, other)
+        @filter = filter
+        @controller = controller
+        @other = other
+        freeze
+      end
+
+      def controller_ok?(object_controller, source)
+        controller == "any" || (controller == "you") == (object_controller == source.controller)
+      end
+
+      # A permanent on the battlefield, by its current characteristics and status.
+      def match?(engine, obj, source)
+        return false if other && obj.id == source.id
+        return false unless controller_ok?(obj.controller, source)
+
+        filter.match_for?(engine, obj.id, source.controller, source.id)
+      end
+
+      # A permanent about to enter under `entering_controller` (CR 614.12: as it would exist there).
+      def match_facts?(facts, entering_controller, source)
+        !filter.nil? && controller_ok?(entering_controller, source) && filter.matches_facts?(facts)
+      end
+
+      def to_s
+        name = filter.is_a?(Class) ? filter.primitive_name.tr("_", " ") : filter.to_s
+        "#{"other " if other}#{name}s#{{ "you" => " you control", "opponent" => " opponents control" }[controller]}"
+      end
+    end
+
+    module Abilities
+      # Base for replacement effects of a permanent's static abilities (CR 614.1, 614.12): no stack.
+      class StaticReplacement < Primitive
+        def mana_ability? = false
+        def allowed_types = nil
+        def try_effects = []
+      end
+
+      # "If you would draw a card, draw two cards instead." (CR 614.11)
+      class DrawReplacement < StaticReplacement
+        primitive :ability, :draw_replacement,
+                  description: "While this permanent is on the battlefield, each time its controller would draw a " \
+                               "card, they draw `amount` cards instead (even with an empty library). The draws it " \
+                               "makes aren't replaced by it again, but another such effect applies to each of them.",
+                  rules: %w[614.11 614.11a 614.5 121.2 616.1],
+                  params: { "amount" => "integer >= 2" },
+                  example: { "draw_replacement" => { "amount" => 2 } }
+
+        attr_reader :amount
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[amount], errors, path)
+          new(Mechanics.integer_param(params, :amount, errors, path, min: 2))
+        end
+
+        def initialize(amount)
+          super()
+          @amount = amount
+          freeze
+        end
+
+        def kind = :draw_replacement
+        def replace_draw = true
+        def to_s = "if you would draw a card, draw #{amount} instead"
+      end
+
+      # "If another creature you control with a +1/+1 counter on it would be destroyed, instead remove all
+      # +1/+1 counters from it and remove all damage from it." (CR 614.1a, regeneration-like 614.8)
+      class DestroyReplacement < StaticReplacement
+        primitive :ability, :destroy_replacement,
+                  description: "If a permanent matching `affects` would be destroyed (by an effect, lethal damage or " \
+                               "deathtouch), instead: all its `remove_counters` counters are removed (if given) and, " \
+                               "with `remove_damage: true`, all damage marked on it is removed. Sacrificing isn't " \
+                               "destroying, and 0 toughness isn't either.",
+                  rules: %w[614.1a 614.8 701.8a 701.21a 704.5f 704.5g 704.5h],
+                  params: { "affects" => "{\"each\": filter, \"controller\": ..., \"other\": bool}",
+                            "remove_counters" => "counter name", "remove_damage" => "boolean" },
+                  example: { "destroy_replacement" => {
+                    "affects" => { "each" => { "creature" => { "counters" => "+1/+1" } }, "controller" => "you", "other" => true },
+                    "remove_counters" => "+1/+1", "remove_damage" => true
+                  } }
+
+        attr_reader :affects, :counter, :damage
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[affects remove_counters remove_damage], errors, path)
+          affects = Affects.build(Mechanics.fetch_param(params, :affects), errors, "#{path}.affects")
+          counter = Mechanics.fetch_param(params, :remove_counters)
+          counter &&= Counters.parse(counter, errors, "#{path}.remove_counters")
+          damage = Mechanics.fetch_param(params, :remove_damage) == true
+          errors << "#{path}: needs remove_counters and/or remove_damage" unless counter || damage
+          new(affects, counter, damage)
+        end
+
+        def initialize(affects, counter, damage)
+          super()
+          @affects = affects
+          @counter = counter
+          @damage = damage
+          freeze
+        end
+
+        def kind = :destroy_replacement
+        def replaces?(engine, obj, source) = affects.match?(engine, obj, source)
+
+        def replace_destroy(engine, obj)
+          engine.remove_all_counters!(obj, counter) if counter
+          engine.remove_damage!(obj) if damage
+        end
+
+        def to_s
+          instead = [counter && "remove all #{counter} counters", damage && "remove all damage"].compact.join(" and ")
+          "if #{affects} would be destroyed, instead #{instead}"
+        end
+      end
+
+      # "If one or more tokens would be created under your control, that many 3/3 Illusion tokens are
+      # created instead." (CR 614.1a, 111.1)
+      class TokenReplacement < StaticReplacement
+        primitive :ability, :token_replacement,
+                  description: "If tokens would be created under this permanent's controller's control, that many " \
+                               "`token` tokens are created instead (tapped or attacking if the originals would be). " \
+                               "`token` is a predefined token name or inline card data.",
+                  rules: %w[614.1a 614.16 111.1 616.1],
+                  params: { "token" => "\"Treasure\" | \"Clue\" | \"Food\" | {card data}" },
+                  example: { "token_replacement" => { "token" => { "name" => "Illusion", "types" => %w[artifact creature],
+                                                                   "subtypes" => ["illusion"], "power" => 3,
+                                                                   "toughness" => 3 } } }
+
+        attr_reader :token_definition
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[token], errors, path)
+          raw = Mechanics.fetch_param(params, :token)
+          data = raw.is_a?(String) ? Enjine::Tokens.fetch(raw) : raw
+          return new(CardDefinition.token(data)) if data.is_a?(Hash)
+
+          errors << "#{path}.token: must be a predefined token (#{Enjine::Tokens::LIBRARY.keys.join(", ")}) or card data"
+          new(nil)
+        rescue InvalidCardDefinition => e
+          e.errors.each { errors << "#{path}.token.#{it}" }
+          new(nil)
+        end
+
+        def initialize(definition)
+          super()
+          @token_definition = definition
+          freeze
+        end
+
+        def kind = :token_replacement
+        def to_s = "if tokens would be created under your control, that many #{token_definition.name} tokens are created instead"
+      end
+
+      # "If one or more tokens would be created under your control, twice that many of those tokens are
+      # created instead." (CR 614.1a, 111.1)
+      class DoubleTokens < StaticReplacement
+        primitive :ability, :double_tokens,
+                  description: "While this permanent is on the battlefield, if tokens would be created under its " \
+                               "controller's control, twice that many of those tokens are created instead. Several " \
+                               "apply one after another (two make four times as many).",
+                  rules: %w[614.1a 614.5 111.1 616.1],
+                  example: "double_tokens"
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, [], errors, path)
+          new
+        end
+
+        def initialize
+          super
+          freeze
+        end
+
+        def kind = :double_tokens
+        def doubles_tokens = true
+        def to_s = "if tokens would be created under your control, twice that many are created instead"
+      end
+
+      # "If a creature an opponent controls would die, exile it instead." (CR 614.1a, 700.4)
+      class ExileIfDiesStatic < StaticReplacement
+        primitive :ability, :exile_if_dies,
+                  description: "While this permanent is on the battlefield, a permanent matching `affects` that would " \
+                               "be put into a graveyard from the battlefield is exiled instead; the card is \"exiled " \
+                               "with\" this permanent (exiled_with). `then`: effects right after (\"instead exile it " \
+                               "and you gain 2 life\"; a reflexive_trigger for \"When you do, ...\"), reading " \
+                               "{\"triggering\": \"object\"} (the exiled card) and \"player\" (who controlled it).",
+                  rules: %w[614.1a 700.4 603.12 607.2a],
+                  params: { "affects" => "{\"each\": filter, \"controller\": you|opponent|any, \"other\": bool}",
+                            "then" => "list of effects" },
+                  example: { "exile_if_dies" => { "affects" => { "each" => "creature", "controller" => "opponent" } } }
+
+        attr_reader :affects, :follow_up
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[affects then], errors, path)
+          new(Affects.build(Mechanics.fetch_param(params, :affects), errors, "#{path}.affects"), FollowUp.build(params, errors, path))
+        end
+
+        def initialize(affects, follow_up = nil)
+          super()
+          @affects = affects
+          @follow_up = follow_up
+          freeze
+        end
+
+        def kind = :exile_if_dies
+        def try_effects = [follow_up].compact
+        def exiles_dying?(engine, obj, source) = affects.match?(engine, obj, source)
+
+        # What happens once the card is exiled: it is linked to `source` (CR 607.2a), then the follow-up.
+        def follow_up_entry(source, obj)
+          facts = { "player" => obj.controller }
+          (follow_up&.entry(source.card, source.controller, source.id, facts) || { "source" => source.id, "facts" => facts })
+            .merge("link" => true)
+        end
+
+        def to_s = "if #{affects} would die, exile it instead#{", then #{follow_up}" if follow_up}"
+      end
+
+      # "Lands you control enter untapped." (CR 614.1c, 614.12; applied after every "enters tapped", 616.1)
+      class EntersUntapped < StaticReplacement
+        primitive :ability, :enters_untapped,
+                  description: "Permanents matching `affects` enter the battlefield untapped, even if another effect " \
+                               "or their own ability would have them enter tapped.",
+                  rules: %w[614.1c 614.12 616.1],
+                  params: { "affects" => "{\"each\": filter, \"controller\": you|opponent|any}" },
+                  example: { "enters_untapped" => { "affects" => { "each" => "land", "controller" => "you" } } }
+
+        attr_reader :affects
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[affects], errors, path)
+          new(Affects.build(Mechanics.fetch_param(params, :affects), errors, "#{path}.affects"))
+        end
+
+        def initialize(affects)
+          super()
+          @affects = affects
+          freeze
+        end
+
+        def kind = :enters_untapped
+        def enters_untapped?(source, controller, facts) = affects.match_facts?(facts, controller, source)
+        def to_s = "#{affects} enter untapped"
+      end
+
+      # "If a creature you control would enter while you control an attacking creature, instead it enters
+      # tapped and attacking." (CR 614.1c, 508.4)
+      class EntersAttacking < StaticReplacement
+        primitive :ability, :enters_attacking,
+                  description: "While this permanent's controller controls an attacking creature, permanents matching " \
+                               "`affects` enter the battlefield tapped and attacking (the defending player). They " \
+                               "never \"attacked\", so attack triggers don't see them.",
+                  rules: %w[614.1c 508.4 506.4],
+                  params: { "affects" => "{\"each\": filter, \"controller\": you|opponent|any}" },
+                  example: { "enters_attacking" => { "affects" => { "each" => "creature", "controller" => "you" } } }
+
+        attr_reader :affects
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[affects], errors, path)
+          new(Affects.build(Mechanics.fetch_param(params, :affects), errors, "#{path}.affects"))
+        end
+
+        def initialize(affects)
+          super()
+          @affects = affects
+          freeze
+        end
+
+        def kind = :enters_attacking
+
+        def enters_attacking?(engine, source, controller, facts)
+          engine.attackers.keys.any? { engine.object(it).controller == source.controller } &&
+            affects.match_facts?(facts, controller, source)
+        end
+
+        def to_s = "#{affects} enter tapped and attacking while you control an attacking creature"
+      end
+    end
+
+    module Effects
+      # "Until end of turn, if one or more counters would be put on a permanent you control, that many plus
+      # one of each of those kinds are put on it instead." (CR 614.1a, 611.2a)
+      class CounterBonus < Effect
+        primitive :effect, :counter_bonus,
+                  description: "Until end of turn, whenever one or more counters would be put on a permanent the " \
+                               "controller controls (including counters it enters with), that many plus `amount` " \
+                               "of each of those kinds are put on it instead.",
+                  rules: %w[614.1a 614.16 611.2a 122.6 616.1],
+                  params: { "amount" => "integer (default 1)" },
+                  example: { "counter_bonus" => { "amount" => 1 } }
+
+        def self.keys = %w[amount if]
+        def self.default_to = "you"
+
+        def initialize(to:, params:, errors:, path:, targets_count: 0, results_count: 0)
+          params = params.transform_keys(&:to_s)
+          params["amount"] = 1 unless params.key?("amount")
+          super
+        end
+
+        def apply(engine, ctx)
+          engine.add_continuous_effect!("counter_bonus", ctx, [], "amount" => amount_for(engine, ctx))
+        end
+
+        def to_s = "until end of turn, counters put on your permanents: that many plus #{amount}"
+      end
+
+      # "If that creature would die this turn, exile it instead." (CR 614.1a, 700.4)
+      class ExileIfDies < Effect
+        primitive :effect, :exile_if_dies,
+                  description: "Until end of turn, if a referenced permanent would be put into a graveyard from the " \
+                               "battlefield, it is exiled instead.",
+                  rules: %w[614.1a 700.4 611.2a 611.2c],
+                  params: { "to" => "selector" },
+                  example: { "exile_if_dies" => { "to" => { "target" => 0 } } }
+
+        def self.keys = %w[to if]
+
+        def apply(engine, ctx) = engine.add_continuous_effect!("exile_if_dies", ctx, objects(engine, ctx), {})
+        def to_s = "if it would die this turn, exile it instead → #{to}"
+      end
+
+      # "Exile [this spell]" as part of its own resolution, so it doesn't go to the graveyard (CR 608.2n).
+      class ExileThisSpell < Effect
+        primitive :effect, :exile_this_spell,
+                  description: "The resolving spell is exiled instead of being put into its owner's graveyard as it " \
+                               "finishes resolving.",
+                  rules: %w[608.2n 406.1],
+                  example: "exile_this_spell"
+
+        def self.keys = %w[if]
+        def self.default_to = "you"
+
+        # The resolving object is on the stack; an ability (not a spell) has no card to exile.
+        def apply(engine, ctx)
+          engine.move!(ctx.object, :exile, reason: "exile") if engine.state.objects[ctx.object]&.kind == "card"
+        end
+
+        def to_s = "exile this spell"
+      end
+    end
+  end
+end