enjine 0.1.0 → 0.2.0

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

@@ -12,24 +12,29 @@ module Enjine
 
         primitive :ability, :additional_triggers,
                   description: "While this permanent is on the battlefield, a triggered ability of a permanent its " \
-                               "controller controls that triggers because of `cause` triggers an additional time. " \
-                               "`cause`: you_gain_life (its controller gaining life).",
-                  rules: %w[603.2d 119.9],
-                  params: { "cause" => CAUSES.join(" | ") },
-                  example: { "additional_triggers" => { "cause" => "you_gain_life" } }
+                               "controller controls triggers an additional time if it triggers because of `cause` " \
+                               "(you_gain_life: its controller gaining life) and/or its permanent matches `of` (a " \
+                               "filter: \"triggered abilities of Allies you control\", {\"creature\": {\"other\": " \
+                               "true, \"subtypes\": \"chosen\"}}). At least one of them.",
+                  rules: %w[603.2d 119.9 607.2d],
+                  params: { "cause" => CAUSES.join(" | "), "of" => "filter of the permanent whose ability triggers" },
+                  example: { "additional_triggers" => { "of" => { "creature" => { "subtypes" => ["ally"] } } } }
 
-        attr_reader :cause
+        attr_reader :cause, :of
 
         def self.build(params, errors, path, **)
-          Mechanics.check_keys(params, %w[cause], errors, path)
+          Mechanics.check_keys(params, %w[cause of], errors, path)
           cause = Mechanics.fetch_param(params, :cause)
-          errors << "#{path}.cause: must be one of #{CAUSES.join(", ")}" unless CAUSES.include?(cause)
-          new(cause)
+          errors << "#{path}.cause: must be one of #{CAUSES.join(", ")}" unless cause.nil? || CAUSES.include?(cause)
+          raw = Mechanics.fetch_param(params, :of)
+          errors << "#{path}: needs cause or of" if cause.nil? && raw.nil?
+          new(cause, raw && Mechanics.build_entry(:filter, raw, errors, "#{path}.of"))
         end
 
-        def initialize(cause)
+        def initialize(cause, filter = nil)
           super()
           @cause = cause
+          @of = filter
           freeze
         end
 
@@ -37,11 +42,18 @@ module Enjine
         def mana_ability? = false
         def allowed_types = nil
         def try_effects = []
-        def to_s = "triggered abilities of your permanents that trigger from you gaining life trigger an additional time"
+
+        def to_s
+          label = of.is_a?(Class) ? of.primitive_name.to_s.tr("_", " ") : of.to_s
+          whose = of ? "each #{label} you control" : "your permanents"
+          "triggered abilities of #{whose}#{" that trigger from you gaining life" if cause} trigger an additional time"
+        end
 
         # `holder`: the permanent with this ability; `source`: the triggering ability's source (a permanent).
         def additional_trigger?(engine, event, holder, source)
           return false unless source["controller"] == holder.controller
+          return false if of && !of.match_for?(engine, source["id"], holder.controller, holder.id)
+          return true if cause.nil?
 
           event.is_a?(Events::LifeChanged) && event.gain.positive? && engine.names.index(event.player) == holder.controller
         end

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

@@ -73,14 +73,17 @@ module Enjine
       class CostModifier < Primitive
         TYPES = %w[artifact creature enchantment land planeswalker instant sorcery].freeze
         CASTERS = %w[you opponent any].freeze
+        SPEC_KEYS = %w[subtypes colors].freeze
 
         primitive :ability, :cost_modifier,
                   description: "While on the battlefield: spells cast by `caster` (you, opponent or any; default you) " \
                                "whose card types match `spells` ({\"any_of\": [types], \"not\": [types]}, default all " \
-                               "spells) cost `reduce` less or `increase` more generic mana. `from` / `not_from`: only " \
+                               "spells; `subtypes` and `colors` narrow it: \"Dragon spells\", \"red spells\") cost " \
+                               "`reduce` less or `increase` more generic mana. `from` / `not_from`: only " \
                                "spells cast from (not from) that zone (hand | graveyard | exile | library | outside).",
                   rules: %w[601.2f 118.7a 604.1 601.2a],
-                  params: { "spells" => "{\"any_of\": [types], \"not\": [types]} (optional)",
+                  params: { "spells" => "{\"any_of\": [types], \"not\": [types], \"subtypes\": [subtypes], \"colors\": [colors]} " \
+                                        "(optional)",
                             "caster" => "you | opponent | any", "reduce" => "amount", "increase" => "amount",
                             "from" => "zone", "not_from" => "zone" },
                   example: { "cost_modifier" => { "spells" => { "not" => ["creature"] }, "reduce" => 1 } }
@@ -94,7 +97,7 @@ module Enjine
             errors << "#{path}.spells: must be an object"
             spells = {}
           end
-          Mechanics.check_keys(spells, %w[any_of not], errors, "#{path}.spells")
+          Mechanics.check_keys(spells, %w[any_of not] + SPEC_KEYS, errors, "#{path}.spells")
           lists = %w[any_of not].to_h do |key|
             list = Array(spells.transform_keys(&:to_s)[key]).map(&:to_s)
             errors << "#{path}.spells.#{key}: must be card types (#{TYPES.join(", ")})" unless (list - TYPES).empty?
@@ -103,7 +106,13 @@ module Enjine
           caster = Mechanics.fetch_param(params, :caster) || "you"
           errors << "#{path}.caster: must be one of #{CASTERS.join(", ")}" unless CASTERS.include?(caster)
           new(caster, lists["any_of"], lists["not"], *build_amount(params, errors, path),
-              zones: CastFrom.build(params, errors, path))
+              zones: CastFrom.build(params, errors, path), spec: build_spec(spells, errors, path))
+        end
+
+        # "Dragon spells", "red spells": the subtypes and colors in `spells`, matched as a card spec.
+        def self.build_spec(spells, errors, path)
+          data = spells.transform_keys(&:to_s).slice(*SPEC_KEYS)
+          data.empty? ? nil : CardSpec.build(data, errors, "#{path}.spells")
         end
 
         def self.build_amount(params, errors, path)
@@ -115,8 +124,9 @@ module Enjine
           [Amount.build(params[keys.first], errors, "#{path}.#{keys.first}", targets_count: 0), keys.first == "reduce" ? -1 : 1]
         end
 
-        def initialize(caster, any_of, not_types, amount, sign, zones: CastFrom.new(nil, nil))
+        def initialize(caster, any_of, not_types, amount, sign, zones: CastFrom.new(nil, nil), spec: nil)
           super()
+          @spec = spec
           @caster = caster
           @any_of = any_of.freeze
           @not_types = not_types.freeze
@@ -135,15 +145,18 @@ module Enjine
         def change_for(engine, permanent, spell, caster_index)
           return 0 unless caster == "any" || (caster == "you") == (caster_index == permanent.controller)
 
-          types = engine.chars(spell).types
+          chars = engine.chars(spell)
+          types = chars.types
           return 0 if types.intersect?(not_types) || !(any_of.empty? || types.intersect?(any_of))
+          return 0 if @spec && !@spec.chars_match?(engine, chars)
           return 0 unless @zones.match?(engine.cast_origin(spell))
 
           sign * amount.value(engine, EffectContext.new(permanent.controller, permanent.id, permanent.id, []))
         end
 
         def to_s
-          kinds = [not_types.map { "non#{it}" }, any_of.join(" or ")].flatten.reject(&:empty?).join(" ")
+          narrow = @spec ? [@spec.colors.map(&:to_s), @spec.subtypes.map { it.to_s.capitalize }] : []
+          kinds = [not_types.map { "non#{it}" }, narrow, any_of.join(" or ")].flatten.reject(&:empty?).join(" ")
           whose = { "you" => "you cast", "opponent" => "your opponents cast", "any" => "" }[caster]
           "#{[kinds, "spells", whose].reject(&:empty?).join(" ")}#{@zones} cost {#{amount}} " \
             "#{sign.negative? ? "less" : "more"}"

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

@@ -76,20 +76,22 @@ module Enjine
                                "`amount` mana (default 1) of one color you choose as you activate it " \
                                "(`\"any_one\"`) or in any combination of colors (`\"any\"`); `colors` limits " \
                                "the choice. `\"chosen\"`: of the color chosen as this entered (choose_color). " \
-                               "`spend_only` restricts how the mana can be spent. `only_if`: \"Activate only if ...\".",
+                               "`spend_only` restricts how the mana can be spent. `only_if`: \"Activate only if ...\". " \
+                               "`limit: \"once_each_turn\"`: \"Activate only once each turn.\"",
                   rules: %w[605.1a 605.3a 605.3b 106.1a 106.4 106.6 607.2d 602.5b],
                   params: { "cost" => "list of costs (e.g. [\"tap\"])",
                             "produce" => "mana symbols added, e.g. \"{G}\" or \"{C}{C}\"",
                             "amount" => "amount (default 1; with produce: how many times)",
                             "color" => CHOICES.join(" | "), "colors" => "list of colors to choose from (default all five)",
                             "spend_only" => "{\"spells\": card spec, \"abilities\": card spec, \"from\" | \"not_from\": zone}",
-                            "only_if" => "condition: it can be activated only while it holds (CR 602.5b)" },
+                            "only_if" => "condition: it can be activated only while it holds (CR 602.5b)",
+                            "limit" => "\"once_each_turn\" (CR 602.5b)" },
                   example: { "mana" => { "cost" => ["tap"], "produce" => "{C}" } }
 
         attr_reader :costs, :produce, :color, :colors, :amount, :spend_only
 
         def self.build(params, errors, path, **)
-          Mechanics.check_keys(params, %w[cost produce amount color colors spend_only only_if], errors, path)
+          Mechanics.check_keys(params, %w[cost produce amount color colors spend_only only_if limit], errors, path)
           costs = build_costs(Mechanics.fetch_param(params, :cost), errors, path)
           raw = Mechanics.fetch_param(params, :produce)
           color = Mechanics.fetch_param(params, :color)
@@ -103,7 +105,8 @@ module Enjine
           raw_if = Mechanics.fetch_param(params, :only_if)
           only_if = raw_if && Condition.build(raw_if, errors, "#{path}.only_if")
           new(costs.compact.freeze, produce, color: color, colors: build_colors(params, color, errors, path),
-                                             amount: amount, spend_only: spend_only, only_if: only_if)
+                                             amount: amount, spend_only: spend_only, only_if: only_if,
+                                             per_turn: build_limit(params, errors, path))
         end
 
         # CR 605.3a: a mana ability is paid for and resolves at once, so none of its costs can wait for a
@@ -126,6 +129,14 @@ module Enjine
             (cost.respond_to?(:mana_cost) && cost.mana_cost.hybrid.any? { Mana.mono_hybrid?(it) })
         end
 
+        LIMITS = { "once_each_turn" => 1 }.freeze
+
+        def self.build_limit(params, errors, path)
+          limit = Mechanics.fetch_param(params, :limit)
+          errors << "#{path}.limit: must be one of #{LIMITS.keys.join(", ")}" unless limit.nil? || LIMITS.key?(limit)
+          LIMITS[limit]
+        end
+
         def self.build_colors(params, color, errors, path)
           raw = Mechanics.fetch_param(params, :colors)
           return COLORS if raw.nil?
@@ -137,8 +148,9 @@ module Enjine
           COLORS
         end
 
-        def initialize(costs, produce, color: nil, colors: COLORS, amount: nil, spend_only: nil, only_if: nil)
+        def initialize(costs, produce, color: nil, colors: COLORS, amount: nil, spend_only: nil, only_if: nil, per_turn: nil)
           super()
+          @per_turn = per_turn
           @costs = costs
           @produce = produce
           @color = color
@@ -164,6 +176,9 @@ module Enjine
           costs.all? { |c| c.payable?(engine, object) } && (mana_cost.nil? || engine.pool_covers?(object.controller, mana_cost))
         end
 
+        # How many times it may be activated each turn (nil: no limit, CR 602.5b); kept by Engine#record_activation!.
+        attr_reader :per_turn
+
         # The sum of its mana costs, or nil.
         attr_reader :mana_cost
 
@@ -201,7 +216,7 @@ module Enjine
                    "#{" (#{colors.join("/")})" unless colors == COLORS}"
                  end
           "#{costs.join(", ")}: #{what}.#{" #{spend_only.to_s.capitalize}." if spend_only}" \
-            "#{" Activate only if #{@only_if}." if @only_if}"
+            "#{" Activate only if #{@only_if}." if @only_if}#{" Activate only once each turn." if per_turn}"
         end
       end
     end

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

@@ -350,8 +350,8 @@ module Enjine
 
           own = costs.filter_map { it.zone if it.respond_to?(:zone) }.first
           errors << "#{path}.zone: its costs are paid from the #{own}" if own && own.to_s != zone
-          if costs.any? { it.is_a?(Costs::Tap) || it.is_a?(Costs::SacrificeSelf) }
-            errors << "#{path}.zone: an ability of a card in the #{zone} can't tap or sacrifice it"
+          if costs.any? { it.is_a?(Costs::Tap) || Costs::LEAVING_SELF.include?(it.class) }
+            errors << "#{path}.zone: an ability of a card in the #{zone} can't tap, sacrifice or exile it"
           end
           zone.to_sym
         end
@@ -386,9 +386,9 @@ module Enjine
         def self.check_cost_zones(costs, errors, path)
           zones = costs.filter_map { it.zone if it.respond_to?(:zone) }.uniq
           errors << "#{path}.cost: costs can't be paid from both #{zones.join(" and ")}" if zones.size > 1
-          return if zones.empty? || costs.none? { it.is_a?(Costs::Tap) || it.is_a?(Costs::SacrificeSelf) }
+          return if zones.empty? || costs.none? { it.is_a?(Costs::Tap) || Costs::LEAVING_SELF.include?(it.class) }
 
-          errors << "#{path}.cost: a cost paid from the #{zones.first} can't be combined with tap or sacrifice"
+          errors << "#{path}.cost: a cost paid from the #{zones.first} can't be combined with tap, sacrifice or exile"
         end
 
         attr_reader :cost_reduction
@@ -513,7 +513,8 @@ module Enjine
                                "and is paid on activation. Sorcery speed, and only one loyalty ability per " \
                                "planeswalker per turn.",
                   rules: %w[606.3 606.4 606.5 602.2b],
-                  params: { "cost" => "integer, e.g. 1 for +1 or -2", "targets" => "list of target filters",
+                  params: { "cost" => "integer, e.g. 1 for +1 or -2; or \"-X\" (X is announced, at most its loyalty)",
+                            "targets" => "list of target filters",
                             "effects" => "list of effects" },
                   example: { "loyalty" => { "cost" => -3, "targets" => ["creature"],
                                             "effects" => [{ "deal_damage" => { "amount" => 3, "to" => { "target" => 0 } } }] } }
@@ -521,8 +522,8 @@ module Enjine
         def self.build(params, errors, path, **)
           Mechanics.check_keys(params, %w[cost] + BODY_KEYS, errors, path)
           cost = Mechanics.fetch_param(params, :cost)
-          errors << "#{path}.cost: must be an integer loyalty change" unless cost.is_a?(Integer)
-          new(**parse_body(params, errors, path), loyalty: cost.to_i)
+          errors << "#{path}.cost: must be an integer loyalty change or \"-X\"" unless cost.is_a?(Integer) || cost == "-X"
+          new(**parse_body(params, errors, path), loyalty: cost == "-X" ? cost : cost.to_i)
         end
 
         def initialize(loyalty:, **)
@@ -531,11 +532,14 @@ module Enjine
         end
 
         def kind = :loyalty
-        def loyalty_cost = @loyalty
+        def loyalty? = true
+        # The fixed loyalty change; a "-X" ability's is chosen as it's activated (CR 107.3, 601.2b), so it's 0 here.
+        def loyalty_cost = x_loyalty? ? 0 : @loyalty
+        def x_loyalty? = @loyalty == "-X"
         def sorcery_speed? = true
         def allowed_types = [:planeswalker]
 
-        def to_s = "#{"+" if @loyalty.positive?}#{@loyalty}: #{effects_text}"
+        def to_s = "#{"+" if !x_loyalty? && @loyalty.positive?}#{@loyalty}: #{effects_text}"
       end
     end
   end

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

@@ -42,7 +42,7 @@ module Enjine
                   example: { "static" => { "affects" => { "each" => "creature", "controller" => "you" },
                                            "pump" => { "power" => 1, "toughness" => 1 } } }
 
-        GRANTABLE = %i[triggered mana activated hexproof_from protection_from tapping_power].freeze
+        GRANTABLE = %i[triggered mana activated loyalty hexproof_from protection_from tapping_power].freeze
         # Data that would make the layer pass depend on its own result (CR 613.8).
         LIVE = %w[power toughness greatest_power attacking blocking tapped].freeze
         KEYS = %w[affects if pump keywords creature_types abilities types subtypes loses_abilities colors
@@ -272,17 +272,22 @@ module Enjine
     module Effects
       # "gains flying until end of turn" (CR 611.2, 613.1f): grant keywords to a locked set.
       class Grant < Effect
+        DURATIONS = %w[end_of_turn until_your_next_turn].freeze
+
         primitive :effect, :grant,
-                  description: "Each referenced permanent (or spell on the stack) gains the `keywords` until end of turn.",
-                  rules: %w[611.2a 611.2c 613.1f 514.2],
-                  params: { "keywords" => "list of keywords", "to" => "selector" },
+                  description: "Each referenced permanent (or spell on the stack) gains the `keywords` until end of turn " \
+                               "(`duration: \"until_your_next_turn\"`: until its controller's next turn begins).",
+                  rules: %w[611.2a 611.2c 613.1f 514.2 500.1],
+                  params: { "keywords" => "list of keywords", "to" => "selector", "duration" => DURATIONS.join(" | ") },
                   example: { "grant" => { "keywords" => ["flying"], "to" => { "target" => 0 } } }
 
         attr_reader :keywords
 
-        def self.keys = %w[keywords to if]
+        def self.keys = %w[keywords to duration if]
 
         def setup(params, errors, path)
+          @duration = Mechanics.fetch_param(params, :duration) || "end_of_turn"
+          errors << "#{path}.duration: must be one of #{DURATIONS.join(", ")}" unless DURATIONS.include?(@duration)
           @keywords = Array(Mechanics.fetch_param(params, :keywords)).map { it.to_s.downcase.tr(" -", "__") }
           errors << "#{path}.keywords: needs at least one keyword" if @keywords.empty?
           @keywords.each { errors << "#{path}.keywords: unknown keyword #{it.inspect}" unless Enjine.registry.fetch(:keyword, it) }
@@ -291,10 +296,11 @@ module Enjine
         # A spell on the stack can gain keywords too ("those spells gain wither", Engine::SpellGrants).
         def apply(engine, ctx)
           spells = refs(engine, ctx).select { (obj = engine.state.objects[it]) && obj.zone == :stack && !obj.ability? }
-          engine.add_continuous_effect!("grant", ctx, objects(engine, ctx) + spells, "keywords" => keywords)
+          engine.add_continuous_effect!("grant", ctx, objects(engine, ctx) + spells, "keywords" => keywords,
+                                                                                     "duration" => @duration)
         end
 
-        def to_s = "gains #{keywords.join(", ")} until end of turn → #{to}"
+        def to_s = "gains #{keywords.join(", ")} until #{@duration.delete_prefix("until_").tr("_", " ")} → #{to}"
       end
 
       # Setting a creature's creature types until end of turn; its other creature types are lost (CR 205.1a, 613.1d).

data/lib/enjine/mechanics/costs/sacrifice.rb

@@ -25,6 +25,31 @@ module Enjine
         def to_s = "Sacrifice this"
       end
 
+      # "Exile this permanent" as a cost (CR 406.1, 602.2b): it leaves the battlefield for exile. Unlike a
+      # sacrifice, nothing that watches sacrifices sees it.
+      class ExileSelf < Primitive
+        primitive :cost, :exile_self,
+                  description: "Exile the permanent the ability belongs to (\"Exile this enchantment: ...\").",
+                  rules: %w[406.1 602.2b 118.3],
+                  example: "exile_self"
+
+        INSTANCE = new.freeze
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, [], errors, path)
+          INSTANCE
+        end
+
+        def mana? = false
+        def uses_source? = true
+        def payable?(engine, object) = engine.state.battlefield.include?(object.id)
+        def pay!(engine, object) = engine.move!(object.id, :exile, reason: "cost")
+        def to_s = "Exile this"
+      end
+
+      # The costs that take the permanent itself off the battlefield (CR 113.6m: not from another zone).
+      LEAVING_SELF = [SacrificeSelf, ExileSelf].freeze
+
       # "Sacrifice a creature" / "Sacrifice another creature or artifact" as a cost (CR 701.21a, 601.2h).
       # The permanent is chosen while casting and sacrificed as the spell or ability becomes cast; what
       # it was (types, subtypes, power) is kept for "if you sacrificed a Klingon this way" (CR 608.2h).
@@ -33,7 +58,7 @@ module Enjine
                   description: "Sacrifice `count` permanents you control matching `filter` (`other: true`: not the " \
                                "source). Chosen while casting or activating, sacrificed as it becomes cast; the " \
                                "sacrificed permanent's last known types and subtypes are remembered (condition " \
-                               "`sacrificed`).",
+                               "`sacrificed`), and its power, toughness and mana value (amount `sacrificed`).",
                   rules: %w[701.21a 601.2h 602.2b 118.3 608.2h],
                   params: { "filter" => "filter (default permanent)", "count" => "integer (default 1)",
                             "other" => "true: not the source itself" },
@@ -44,7 +69,8 @@ module Enjine
             perm = engine.object(entry["object"])
             facts = engine.chars(perm)
             entry.merge!("types" => facts.types.map(&:to_s), "subtypes" => facts.subtypes.map(&:to_s),
-                         "power" => engine.power(perm))
+                         "power" => engine.power(perm), "toughness" => engine.toughness(perm),
+                         "mana_value" => Amount.mana_value(engine, perm))
             engine.move!(perm.id, :graveyard, reason: "sacrifice")
           end
         end

data/lib/enjine/mechanics/effects/become.rb

@@ -12,7 +12,8 @@ module Enjine
       # on the battlefield. Granted abilities are part of this card's data, referenced "<this effect's ref>:<j>"
       # (CardDefinition#effect_granted); on the permanent they are "granted:<card>:<ref>:<j>".
       class Become < Effect
-        DURATIONS = %w[end_of_turn indefinite while_source_on_battlefield while_you_control_source].freeze
+        DURATIONS = %w[end_of_turn until_your_next_turn indefinite while_source_on_battlefield
+                       while_you_control_source].freeze
         GRANTABLE = %i[triggered mana activated play_from additional_land_plays hexproof_from protection_from].freeze
         # Card types an effect can add (CR 205.1b); instants, sorceries and planeswalkers aren't permanents it makes.
         ADDABLE_TYPES = %w[artifact creature enchantment land].freeze
@@ -21,7 +22,8 @@ module Enjine
 
         primitive :effect, :become,
                   description: "Each referenced permanent becomes what the parameters say, for `duration` " \
-                               "(end_of_turn, default; indefinite: as long as it stays on the battlefield; " \
+                               "(end_of_turn, default; until_your_next_turn: until your next turn begins; indefinite: " \
+                               "as long as it stays on the battlefield; " \
                                "while_source_on_battlefield: for as long as this effect's source remains on the " \
                                "battlefield; while_you_control_source: for as long as you control it): it has " \
                                "the card `types`, `supertypes` and `subtypes` in addition to its other types (layer 4, " \
@@ -52,6 +54,8 @@ module Enjine
         attr_reader :ref, :creature_types, :base_power_toughness, :granted_abilities, :duration, :card_types,
                     :supertypes, :subtypes, :colors, :keywords
 
+        UNTIL = { "end_of_turn" => " until end of turn", "until_your_next_turn" => " until your next turn" }.freeze
+
         def self.keys = CHANGES + %w[duration to if]
 
         # A list of registered names (card types, supertypes, keywords) as symbols; [] when absent.
@@ -96,7 +100,7 @@ module Enjine
         def duration_details(engine, ctx)
           case @duration
           when "indefinite" then { "duration" => "permanent" }
-          when "end_of_turn" then { "duration" => "end_of_turn" }
+          when "end_of_turn", "until_your_next_turn" then { "duration" => @duration } # CR 611.2a, 500.1
           else
             holds = engine.source_duration_holds?(@duration, ctx.source, ctx.controller)
             holds ? { "duration" => @duration, "source" => ctx.source } : nil
@@ -132,7 +136,7 @@ module Enjine
           bits << "base #{base_power_toughness.values.join("/")}" if base_power_toughness
           bits << keywords.join(", ") unless keywords.empty?
           bits << "\"#{granted_abilities.join("; ")}\"" unless granted_abilities.empty?
-          "becomes #{bits.join(", ")}#{" until end of turn" if duration == "end_of_turn"} → #{to}"
+          "becomes #{bits.join(", ")}#{UNTIL[duration]} → #{to}"
         end
 
         def self.parse_colors(raw, errors, path)

data/lib/enjine/mechanics/effects/choose_cards.rb

@@ -10,7 +10,7 @@ module Enjine
       class ChooseCards < ChoiceEffect
         include NestedList
 
-        PUT = %w[hand graveyard exile battlefield library_top library_bottom].freeze
+        PUT = %w[hand graveyard exile battlefield library_top library_bottom discard].freeze
         ZONES = %w[hand graveyard].freeze
         REVEAL = %w[chosen all].freeze
         LISTS = %w[then otherwise].freeze
@@ -19,12 +19,12 @@ module Enjine
                   description: "You choose `count` (default 1; \"any\": any number) cards matching `for` from `from`: a " \
                                "selector (e.g. {\"result\": 0}, the cards an earlier effect milled) or a player's zone, " \
                                "{\"hand\": selector} / {\"graveyard\": selector}. `optional`: you may choose fewer. Then " \
-                               "they are put into `put` (`tapped` onto the battlefield, under your control; exiled cards " \
-                               "`link`ed to the source). `look`: you look at the whole zone first; `reveal`: \"chosen\" " \
-                               "reveals what you chose, \"all\" the whole set. `then` runs if a card was chosen, " \
-                               "`otherwise` if none was (\"if you can't\"). `random: true`: the cards are picked at random " \
-                               "(the game's random number generator) instead of chosen.",
-                  rules: %w[701.20a 701.20e 400.7j 608.2c 607.2a 118.12 701.9b],
+                               "they are put into `put` (`discard`: from a hand, its owner discards them; `tapped` onto the " \
+                               "battlefield, under your control; exiled cards `link`ed to the source). `look`: you look at the " \
+                               "whole zone first; `reveal`: \"chosen\" reveals what you chose, \"all\" the whole set. " \
+                               "`then` runs if a card was chosen, `otherwise` if none was (\"if you can't\"). `random: true`: the " \
+                               "cards are picked at random (the game's random number generator) instead of chosen.",
+                  rules: %w[701.20a 701.20e 400.7j 608.2c 607.2a 118.12 701.9a 701.9b],
                   params: { "from" => "selector or {\"hand\"|\"graveyard\": player selector}", "for" => "card spec",
                             "count" => "integer or \"any\"", "optional" => "boolean", "put" => PUT.join(" | "),
                             "tapped" => "boolean", "link" => "boolean", "look" => "boolean", "random" => "boolean",
@@ -47,6 +47,7 @@ module Enjine
           @optional = Mechanics.flag_param(params, "optional", errors, path)
           @put = Mechanics.fetch_param(params, :put).to_s
           errors << "#{path}.put: must be one of #{PUT.join(", ")}" unless PUT.include?(@put)
+          errors << "#{path}.put: discard takes cards from a hand" if @put == "discard" && @from_zone != "hand"
           @flags = %w[tapped link look random].to_h { [it, Mechanics.flag_param(params, it, errors, path)] }
           errors << "#{path}.count: must be a number to pick at random" if @flags["random"] && @count == "any"
           @reveal = Mechanics.fetch_param(params, :reveal)
@@ -154,6 +155,7 @@ module Enjine
 
         def move(engine, ctx, id)
           case put
+          when "discard" then engine.move!(id, :graveyard, reason: "discard") # CR 701.9a: the owner discards it
           when "library_top", "library_bottom"
             engine.move!(id, :library, reason: "put", position: put == "library_top" ? :top : :bottom)
           else

data/lib/enjine/mechanics/effects/delayed_triggers.rb

@@ -104,7 +104,8 @@ module Enjine
           source = { "id" => ctx.source, "card" => card, "controller" => ctx.controller, "ability" => ref }
           engine.queue_pending_trigger!(source, nil, { "results" => Snapshot.deep_copy(ctx.results || []),
                                                        "amounts" => (ctx.amounts || []).dup,
-                                                       "triggering" => memory["triggering"]&.dup }.compact)
+                                                       "triggering" => memory["triggering"]&.dup,
+                                                       "departed" => engine.departed_snapshot }.compact)
         end
       end
     end

data/lib/enjine/mechanics/effects/search.rb

@@ -6,7 +6,8 @@ module Enjine
   module Mechanics
     module Effects
       # Search your library (CR 701.23), optionally reveal what was found (CR 701.20a), put it
-      # into your hand or onto the battlefield, then shuffle (CR 701.24).
+      # into your hand, onto the battlefield or into your graveyard, then shuffle (CR 701.24); or shuffle
+      # and put the found card on top ("then shuffle and put that card on top").
       #
       # The searcher picks one card at a time. Copies of the same card in a library are
       # interchangeable, so each distinct card is offered once. Only the searcher sees the
@@ -17,7 +18,9 @@ module Enjine
 
         primitive :effect, :search_library,
                   description: "Search your library for up to `count` cards matching `for`, then put them into your " \
-                               "hand (or onto the battlefield, tapped if `tapped`, with `counters`) and shuffle. With a " \
+                               "hand (or onto the battlefield, tapped if `tapped`, with `counters`; or into your " \
+                               "graveyard) and shuffle. `put: library_top`: shuffle, then put the found card (one) on top. " \
+                               "Computed bounds in `for` are worked out as the effect resolves. With a " \
                                "stated quality you may find fewer (or none); a search for just \"a card\" must find one " \
                                "if it can. `reveal` shows the found cards to every player. `searcher` names another " \
                                "player who searches their own library (e.g. {\"controller_of\": {\"target\": 0}}); " \
@@ -27,7 +30,7 @@ module Enjine
                   params: { "for" => "card spec: \"card\" (default), {\"types\"|\"subtypes\"|\"supertypes\": [...], " \
                                      "\"name\": \"...\"} or {\"any_of\": [spec, ...]}",
                             "count" => "integer (default 1), \"any\" (any number), \"x\" or an amount (\"up to that many\")",
-                            "put" => "\"hand\" (default) or \"battlefield\"",
+                            "put" => "\"hand\" (default), \"battlefield\", \"graveyard\" or \"library_top\" (count 1)",
                             "tapped" => "true: the cards enter tapped (with put: battlefield)",
                             "counters" => "{counter name: n}: the cards enter with these counters (with put: battlefield)",
                             "reveal" => "true: reveal the found cards",
@@ -37,7 +40,7 @@ module Enjine
                   example: { "search_library" => { "for" => { "supertypes" => ["basic"], "types" => ["land"] },
                                                    "reveal" => true } }
 
-        ZONES = %w[hand battlefield].freeze
+        ZONES = %w[hand battlefield graveyard library_top].freeze
 
         attr_reader :spec, :count, :put, :tapped, :reveal
 
@@ -54,6 +57,7 @@ module Enjine
           @may = Mechanics.flag_param(params, :may, errors, path)
           @different_names = Mechanics.flag_param(params, :different_names, errors, path)
           errors << "#{path}.tapped: only cards put onto the battlefield can enter tapped" if @tapped && @put != "battlefield"
+          errors << "#{path}.count: put library_top takes one card" if @put == "library_top" && @count != 1
           @counters = parse_counters(Mechanics.fetch_param(params, :counters), errors, path)
           raw = Mechanics.fetch_param(params, :searcher) || "you"
           @searcher = Selector.build(raw, errors, "#{path}.searcher", targets_count: @targets_count, results_count: @results_count)
@@ -101,7 +105,7 @@ module Enjine
           end
           found = answers(locals).select { it["type"] == "find" }.map { it["object"] }
           unless stop?(engine, ctx, locals, found)
-            choices = candidates(engine, index, found)
+            choices = candidates(engine, ctx, index, found)
             return ask(engine, locals, index, "Search your library (#{spec}): find a card", choices) unless choices.empty?
           end
           return :wait if entering_choices?(engine, index, locals, found)
@@ -127,10 +131,11 @@ module Enjine
 
         # One option per distinct matching card (CR 701.23a); "done" stops looking unless the
         # search is for just a quantity of cards (CR 701.23b, 701.23d).
-        def candidates(engine, index, found)
+        # Computed bounds ("mana value equal to 1 plus the sacrificed artifact's") are worked out now (CR 608.2h).
+        def candidates(engine, ctx, index, found)
           names = @different_names ? found.map { engine.chars(it).name } : []
           ids = (engine.player(index).library - found).sort.select do
-            spec.match?(engine, engine.object(it)) && !names.include?(engine.chars(it).name)
+            spec.match?(engine, engine.object(it), ctx) && !names.include?(engine.chars(it).name)
           end
           choices = ids.uniq { engine.object(it).card }.map { { "type" => "find", "object" => it } }
           return choices if choices.empty? || (spec.any? && count != "any")
@@ -139,11 +144,13 @@ module Enjine
         end
 
         def finish!(engine, index, found, locals)
-          if reveal && put == "hand"
+          if reveal && %w[hand library_top].include?(put)
             found.each do |id|
               engine.emit Events::CardRevealed.new(player: engine.name(index), object: id, card: engine.object(id).card)
             end
           end
+          return engine.shuffle_library!(index, then_on_top: found) if put == "library_top" # CR 701.24a
+
           enters = {}
           enters["tapped"] = true if tapped
           enters["counters"] = @counters.dup unless @counters.empty?