enjine 0.1.0

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # "You may [effects]. If you do, [then]. If you don't, [otherwise]." (CR 118.12): the controller
+      # answers yes or no while it resolves (an effect_choice). Yes is offered only when every effect
+      # in `effects` can be done fully, as for any cost (CR 118.3). `then` follows a yes and
+      # `otherwise` a no, whatever the effects actually did.
+      class May < ChoiceEffect
+        include NestedList
+
+        LISTS = %w[effects then otherwise].freeze
+
+        primitive :effect, :may,
+                  description: "An optional effect. The controller chooses yes or no as it resolves; yes is offered only " \
+                               "if every effect in `effects` can be done fully. On yes, `effects` then `then` (\"if you " \
+                               "do\") happen; on no, `otherwise` (\"if you don't\"). Nested effects may name the results " \
+                               "of earlier effects of the enclosing list.",
+                  rules: %w[118.12 118.3 608.2d 608.2e],
+                  params: { "effects" => "list of effects (the optional part)", "then" => "list of effects",
+                            "otherwise" => "list of effects",
+                            "chooser" => "who decides (default: the controller): a selector naming a player, or a " \
+                                         "permanent whose controller decides (e.g. {\"target\": 0}), or " \
+                                         "\"active_player\"" },
+                  example: { "may" => { "effects" => [{ "discard" => { "amount" => 1 } }],
+                                        "then" => [{ "draw" => { "amount" => 1 } }] } }
+
+        def self.keys = LISTS + %w[if chooser]
+        def self.default_to = "you"
+
+        def setup(params, errors, path)
+          @lists = parse_lists(params, errors, path, LISTS)
+          errors << "#{path}.effects: needs at least one effect" if @lists["effects"].empty?
+          raw = Mechanics.fetch_param(params, :chooser)
+          @chooser = if raw.nil? || raw == "active_player" then raw
+                     else Selector.build(raw, errors, "#{path}.chooser", targets_count: @targets_count, results_count: @results_count)
+                     end
+        end
+
+        def effects = @lists["effects"]
+        def nested_effects = @lists.values.flatten
+
+        # CR 608.2e: an effect may have a player other than its controller make a choice. The chooser is
+        # the named player, or the controller of the named permanent; nobody legal: the controller.
+        def chooser_index(engine, ctx)
+          return ctx.controller if @chooser.nil?
+          return engine.state.active if @chooser == "active_player"
+
+          ref = @chooser.resolve(engine, ctx).first
+          Filters.player_index(engine, ref) || engine.state.objects[ref]&.controller || ctx.controller
+        end
+
+        def to_s
+          text = "#{@chooser ? "#{@chooser} may have" : "you may"}: #{effects.join("; ")}"
+          text += " — if you do: #{@lists["then"].join("; ")}" unless @lists["then"].empty?
+          text += " — if you don't: #{@lists["otherwise"].join("; ")}" unless @lists["otherwise"].empty?
+          text
+        end
+
+        def run(engine, ctx, locals)
+          unless locals["chose"]
+            return :done unless condition.nil? || condition.true?(engine, ctx)
+
+            answer = answers(locals).first or return ask_yes_no(engine, ctx, locals)
+            locals["chose"] = answer["type"]
+            locals["next"] = 0
+          end
+          run_list(engine, ctx, locals, locals["chose"] == "yes" ? effects + @lists["then"] : @lists["otherwise"])
+        end
+
+        private
+
+        def ask_yes_no(engine, ctx, locals)
+          choices = [{ "type" => "no" }]
+          choices.unshift({ "type" => "yes" }) if effects.all? { it.possible?(engine, ctx) }
+          ask(engine, locals, chooser_index(engine, ctx), "You may: #{effects.join("; ")}", choices)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # "Exile them, then meld them into [back face]" (CR 701.42a, 713.1a): the source, and a creature named
+      # `with` that its controller both owns and controls, are exiled; if the two are a meld pair (CR 701.42b)
+      # they come back as one permanent with the combined back face up (Engine::Faces#meld!), else they stay
+      # exiled (CR 701.42c). The melded permanent is its result.
+      class Meld < Effect
+        primitive :effect, :meld,
+                  description: "Exile this permanent and a creature named `with` that you both own and control, then " \
+                               "meld them: a meld pair (cards with layout \"meld\" sharing a back face) enters the " \
+                               "battlefield as one permanent with that back face up. When it leaves the battlefield, " \
+                               "both cards go to the new zone.",
+                  rules: %w[701.42a 701.42b 701.42c 713.1a 713.6 713.8],
+                  params: { "with" => "the name of the other card of the pair" },
+                  example: { "meld" => { "with" => "Fang, Fearless l'Cie" } }
+
+        def self.keys = %w[with if]
+        def self.default_to = "self"
+
+        def setup(params, errors, path)
+          @with = Mechanics.fetch_param(params, :with)
+          errors << "#{path}.with: must be a card name" unless @with.is_a?(String) && !@with.empty?
+        end
+
+        def apply(engine, ctx)
+          pair = [Condition::MeldWith.own(engine, ctx.controller, ctx.source),
+                  Condition::MeldWith.partner(engine, ctx.controller, @with)]
+          exiled = pair.compact.filter_map { engine.move!(it, :exile, reason: "meld") }
+          engine.meld!(*exiled, ctx.controller) if exiled.size == 2
+        end
+
+        def to_s = "exile this and #{@with}, then meld them"
+      end
+    end
+
+    class Condition
+      # "If you both own and control [this] and a creature named [name]" (the meld cards' condition, CR 713.1a):
+      # `{"meld_with": name}`.
+      class MeldWith
+        def self.build(data, errors, path)
+          Mechanics.check_keys(data, %w[meld_with], errors, path)
+          name = data["meld_with"]
+          errors << "#{path}.meld_with: must be a card name" unless name.is_a?(String) && !name.empty?
+          new(name)
+        end
+
+        # The source, if it's a permanent `index` owns and controls.
+        def self.own(engine, index, id)
+          obj = engine.state.objects[id]
+          id if obj&.zone == :battlefield && obj.owner == index && obj.controller == index
+        end
+
+        # A creature named `name` that `index` owns and controls.
+        def self.partner(engine, index, name)
+          engine.state.battlefield.find do |id|
+            obj = engine.object(id)
+            obj.owner == index && obj.controller == index && (c = engine.chars(obj)).creature? && c.name == name
+          end
+        end
+
+        def initialize(name)
+          @name = name
+          freeze
+        end
+
+        def true?(engine, ctx)
+          !MeldWith.own(engine, ctx.controller, ctx.source).nil? && !MeldWith.partner(engine, ctx.controller, @name).nil?
+        end
+
+        def to_s = "you both own and control this and a creature named #{@name}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Mill N cards (CR 701.17).
+      class Mill < Effect
+        primitive :effect, :mill, description: "Each referenced player puts the top `amount` cards of their library " \
+                                               "into their graveyard (default: you).",
+                                  rules: %w[701.17a], params: { "amount" => "integer", "to" => "selector" },
+                                  example: { "mill" => { "amount" => 2, "to" => "each_opponent" } }
+        def self.default_to = "you"
+
+        def apply(engine, ctx)
+          players(engine, ctx).each do |index|
+            engine.player(index).library.first(amount_for(engine, ctx)).each { engine.move!(it, :graveyard, reason: "mill") }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Paying a cost while a spell or ability resolves (CR 118.12): any costs (mana, life, discarding,
+      # sacrificing, poison counters, a choice between costs). The payer is asked whether to pay — one choice per
+      # way the costs could be paid now (CR 118.3), so a `one_of` is chosen with it — then makes the cost's choices
+      # (which card to discard) one `effect_choice` at a time, then pays the mana in a "pay" frame (mana abilities
+      # allowed, CR 605.3a); declining or cancelling that payment counts as not paying, and nothing is paid (a card
+      # revealed to behold stays revealed, a permanent tapped for a cost stays tapped). The rest is paid once the
+      # mana is.
+      module PaysCosts
+        # The costs given as `cost` (a list), or as the shorthands `mana`, `life` and `waterbend`.
+        def parse_payment(params, errors, path)
+          keys = %w[mana life waterbend cost] & self.class.keys
+          given = keys.reject { Mechanics.fetch_param(params, it).nil? }
+          errors << "#{path}: needs exactly one of #{keys.join(", ")}" unless given.size == 1
+          raw = given.first && Mechanics.fetch_param(params, given.first)
+          case given.first
+          when "cost"
+            Abilities::StackAbility.parse_costs(params, errors, path).tap do
+              errors << "#{path}.cost: must be a non-empty list" if it.empty?
+            end
+          when "life"
+            return [Costs::PayLife.new(raw)].freeze if raw.is_a?(Integer) && raw >= 1
+
+            (errors << "#{path}.life: must be an integer >= 1") && [].freeze
+          when nil then [].freeze
+          else [Mechanics.build_entry(:cost, { given.first => raw }, errors, path)].compact.freeze
+          end
+        end
+
+        # Each way of paying `costs` open to the payer now: its other parts payable for `payer_obj` (an object
+        # the payer controls, CR 118.3) and its mana affordable.
+        def open_variants(engine, payer_obj, costs)
+          engine.cost_variants(costs).each_index.select do |i|
+            variant = engine.cost_variants(costs)[i]
+            variant.reject(&:mana?).all? { it.payable?(engine, payer_obj) } &&
+              engine.affordable?(payer_obj.controller, engine.costs_mana(variant), nil, engine.waterbend_purpose(variant))
+          end
+        end
+
+        # `{type: "pay"}` (with `option` and `cost` when the costs can be paid more than one way) for each open way.
+        def pay_choices(engine, payer_obj, costs)
+          ways = engine.cost_variants(costs)
+          open_variants(engine, payer_obj, costs).map do |i|
+            ways.size == 1 ? { "type" => "pay" } : { "type" => "pay", "option" => i, "cost" => ways[i].join(", ") }
+          end
+        end
+
+        # "{2}", "3 life", "discard a card or {2}".
+        def costs_text(costs) = costs.map { it.to_s.gsub(/(\A| or )[Pp]ay /, "\\1").sub(/\A\w/, &:downcase) }.join(", ")
+
+        # After a "pay" answer: makes the choices, pays the mana, then the rest. :wait while asking or paying
+        # mana; otherwise "paid" or "unpaid".
+        def pay_costs(engine, ctx, locals, payer_obj, costs)
+          paying = locals["paying"] ||= { "variant" => answers(locals).last["option"].to_i, "entries" => {},
+                                          "seen" => answers(locals).size }
+          variant = engine.cost_variants(costs)[paying["variant"]]
+          if answers(locals).size > paying["seen"]
+            paying["seen"] = answers(locals).size
+            answer = answers(locals).last
+            return "unpaid" if paying.delete("mana") && answer["type"] != "paid"
+
+            take_choice(engine, paying, variant, answer) if paying["cost"]
+          end
+          choose_next(engine, locals, paying, variant, payer_obj) || pay_variant(engine, ctx, paying, variant, payer_obj)
+        end
+
+        private
+
+        def take_choice(engine, paying, variant, answer)
+          i = paying.delete("cost")
+          (paying["entries"][i.to_s] ||= []) << variant[i].choose!(engine, { object: answer["object"] })
+        end
+
+        # Asks for the next choice a cost needs (CR 601.2h, as for casting); nil when none is left.
+        def choose_next(engine, locals, paying, variant, payer_obj)
+          variant.each_with_index do |cost, i|
+            next unless cost.respond_to?(:choices_needed)
+
+            chosen = paying["entries"].fetch(i.to_s, [])
+            options = cost.choice_options(engine, payer_obj, chosen)
+            next if chosen.size >= cost.choices_needed || options.empty?
+
+            paying["cost"] = i
+            return ask(engine, locals, payer_obj.controller, cost.to_s, options.map { { "type" => "cost", "object" => it[:object] } })
+          end
+          nil
+        end
+
+        def pay_variant(engine, ctx, paying, variant, payer_obj)
+          mana = engine.costs_mana(variant)
+          if mana.mana_value.positive? && !paying["mana_paid"]
+            paying["mana"] = paying["mana_paid"] = true
+            bend = engine.waterbend_generic(variant)
+            engine.begin_payment!(payer_obj.controller, mana, ctx.object, waterbend: bend.positive? ? bend : nil)
+            return :wait
+          end
+          variant.each_with_index do |cost, i|
+            next if cost.mana?
+
+            if cost.respond_to?(:choices_needed)
+              cost.pay_chosen!(engine, payer_obj,
+                               paying["entries"].fetch(i.to_s, []))
+            else
+              cost.pay!(engine, payer_obj)
+            end
+          end
+          "paid"
+        end
+      end
+
+      # "[Player] may pay {1}. If they do, [then]. If they don't, [otherwise]." (CR 118.12): the payer answers
+      # pay or decline (pay only when the cost can be paid, CR 118.3), then pays (PaysCosts).
+      class Pay < ChoiceEffect
+        include NestedList
+        include PaysCosts
+
+        LISTS = %w[then otherwise].freeze
+
+        primitive :effect, :pay,
+                  description: "You may pay `cost` (a list of costs: mana, life, discarding, sacrificing, a `one_of` " \
+                               "choice, ...) as it resolves; `mana`, `life` and `waterbend` are shorthands for one cost. " \
+                               "If you do, `then` happens; if you don't, `otherwise`. Paying mana works like paying a " \
+                               "spell's cost (mana abilities may be activated; a `waterbend` cost may also be paid by " \
+                               "tapping artifacts and creatures, CR 701.67a); a cost that can't be paid can't be " \
+                               "chosen (CR 118.3). For another player paying, see `counter_unless_pays`.",
+                  rules: %w[118.12 118.12a 118.3 119.4 605.3a 701.67a 701.67c],
+                  params: { "cost" => "list of costs, e.g. [{\"one_of\": [{\"sacrifice_permanent\": {\"filter\": " \
+                                      "\"artifact\"}}, {\"discard\": {}}]}]",
+                            "mana" => "mana cost string, e.g. \"{1}\"", "life" => "integer",
+                            "waterbend" => "mana cost string: \"unless you waterbend {2}\"",
+                            "then" => "list of effects",
+                            "otherwise" => "list of effects" },
+                  example: { "pay" => { "mana" => "{1}", "then" => [{ "draw" => { "amount" => 1 } }] } }
+
+        attr_reader :costs
+
+        def self.keys = %w[cost mana life waterbend then otherwise if]
+        def self.default_to = "you"
+
+        def setup(params, errors, path)
+          @costs = parse_payment(params, errors, path)
+          @lists = parse_lists(params, errors, path, LISTS)
+        end
+
+        def nested_effects = @lists.values.flatten
+        def what = costs_text(costs)
+
+        def to_s
+          text = "you may pay #{what}"
+          text += " — if paid: #{@lists["then"].join("; ")}" unless @lists["then"].empty?
+          text += " — if not: #{@lists["otherwise"].join("; ")}" unless @lists["otherwise"].empty?
+          text
+        end
+
+        def run(engine, ctx, locals)
+          unless locals["outcome"]
+            return :done unless condition.nil? || condition.true?(engine, ctx)
+
+            status = decide(engine, ctx, locals)
+            return status if status == :wait
+
+            locals["next"] = 0
+          end
+          run_list(engine, ctx, locals, @lists[locals["outcome"] == "paid" ? "then" : "otherwise"])
+        end
+
+        private
+
+        # Asks pay or decline, then pays; returns :wait while a decision or the payment is pending.
+        def decide(engine, ctx, locals)
+          payer = engine.object(ctx.object)
+          unless locals["paying"] || answers(locals).first
+            choices = pay_choices(engine, payer, costs) + [{ "type" => "decline" }]
+            return ask(engine, locals, payer.controller, "Pay #{what}?", choices)
+          end
+          return locals["outcome"] = "unpaid" if answers(locals).first["type"] == "decline"
+
+          result = pay_costs(engine, ctx, locals, payer, costs)
+          result == :wait ? :wait : (locals["outcome"] = result)
+        end
+      end
+
+      # "Counter target spell unless its controller pays {3}." (CR 701.6a, 118.12a): the spell's (or
+      # ability's) controller may pay (PaysCosts); if they don't, it's countered.
+      class CounterUnlessPays < ChoiceEffect
+        include PaysCosts
+
+        primitive :effect, :counter_unless_pays,
+                  description: "Counter each referenced spell or ability unless its controller pays `mana` (or " \
+                               "`waterbend`s that cost, CR 701.67a, or pays the list of costs `cost`) as this " \
+                               "resolves (they choose, and pay like any cost; mana abilities allowed).",
+                  rules: %w[701.6a 118.12a 605.3a 701.67a],
+                  params: { "mana" => "mana cost string", "waterbend" => "mana cost string, instead of mana",
+                            "cost" => "list of costs, instead of mana", "to" => "selector (usually {\"target\": 0})" },
+                  example: { "counter_unless_pays" => { "mana" => "{3}", "to" => { "target" => 0 } } }
+
+        def self.keys = %w[mana waterbend cost to if]
+
+        attr_reader :costs
+
+        def setup(params, errors, path) = @costs = parse_payment(params, errors, path)
+
+        def what = costs_text(costs)
+        def to_s = "counter #{to} unless its controller pays #{what}"
+
+        def run(engine, ctx, locals)
+          return :done unless locals["target"] || condition.nil? || condition.true?(engine, ctx)
+
+          target = (locals["target"] ||= on_stack(engine, ctx).first) or return :done
+
+          payer = engine.object(target)
+          unless locals["paying"] || answers(locals).first
+            choices = pay_choices(engine, payer, costs) + [{ "type" => "decline" }]
+            return ask(engine, locals, payer.controller, "Pay #{what} or #{payer.card} is countered?", choices)
+          end
+          paid = answers(locals).first["type"] == "pay" && pay_costs(engine, ctx, locals, payer, costs)
+          return :wait if paid == :wait
+
+          engine.counter!(target) unless paid == "paid"
+          :done
+        end
+
+        def on_stack(engine, ctx) = refs(engine, ctx).select { engine.state.stack.include?(it) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../abilities/turn_rules"
+require_relative "../keywords/evergreen"
+
+module Enjine
+  module Mechanics
+    module Effects
+      # "All artifacts and creatures phase out" (CR 702.26b): the permanents
+      # are treated as though they don't exist until they phase in during their controller's next untap step
+      # (CR 502.1). Auras and Equipment attached to them phase out with them (CR 702.26g). See
+      # Engine::TurnStructure.
+      class PhaseOut < Effect
+        primitive :effect, :phase_out,
+                  description: "Each referenced permanent phases out, with the Auras and Equipment attached to it " \
+                               "(indirectly). It phases in during the untap step of the player who controlled it as " \
+                               "it phased out. Phasing isn't a zone change: no enters or leaves triggers.",
+                  rules: %w[702.26a 702.26b 702.26d 702.26g 702.26h 502.1 506.4],
+                  params: { "to" => "selector" },
+                  example: { "phase_out" => { "to" => { "each" => { "permanent" => { "any_of" => %w[artifact creature] } } } } }
+
+        def self.keys = %w[to if]
+
+        def apply(engine, ctx) = engine.phase_out!(objects(engine, ctx))
+
+        def to_s = "phase out → #{to}"
+      end
+    end
+
+    module Keywords
+      Evergreen.define(:phasing, "During each of its controller's untap steps, before they untap, it phases out if " \
+                                 "it's phased in (and phases in if it phased out under their control).",
+                       %w[702.26a 702.26p 502.1])
+    end
+
+    module Abilities
+      # "Permanents can't phase in" (CR 702.26a, 502.1): while this permanent is on the battlefield, nothing
+      # phases in during untap steps.
+      class CantPhaseIn < Abilities::TurnRule
+        primitive :ability, :cant_phase_in,
+                  description: "While this permanent is on the battlefield, permanents can't phase in.",
+                  rules: %w[702.26a 502.1 604.1], example: "cant_phase_in"
+
+        INSTANCE = new.freeze
+
+        def kind = :cant_phase_in
+        def to_s = "Permanents can't phase in"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Proliferate (CR 701.34a): choose any number of permanents and/or players that have a counter, then
+      # give each one another counter of each kind it already has. "Proliferate X times" repeats it.
+      class Proliferate < ChoiceEffect
+        primitive :effect, :proliferate,
+                  description: "You choose any number of permanents and/or players that have counters (one at a time, " \
+                               "then done); each gets one more counter of each kind already on it. `amount` (default " \
+                               "1): how many times to proliferate.",
+                  rules: %w[701.34a 122.1 122.6],
+                  params: { "amount" => "amount (default 1)" },
+                  example: { "proliferate" => {} }
+
+        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 to_s = "proliferate#{" #{amount} times" if amount != 1}"
+
+        # Each round asks until "done" (or nothing is left to choose), then gives the counters.
+        def run(engine, ctx, locals)
+          unless locals["times"]
+            return :done unless condition.nil? || condition.true?(engine, ctx)
+
+            locals["times"] = amount_for(engine, ctx)
+          end
+          while locals["times"].positive?
+            chosen = answers(locals).reject { it["type"] == "done" }.map { it["object"] }
+            options = answers(locals).any? { it["type"] == "done" } ? [] : candidates(engine, chosen)
+            return ask(engine, locals, ctx.controller, "Proliferate: choose a permanent or player", options + DONE) unless options.empty?
+
+            chosen.each { give!(engine, ctx, it) }
+            locals["times"] -= 1
+            locals.delete("answers")
+          end
+          :done
+        end
+
+        DONE = [{ "type" => "done" }].freeze
+
+        private
+
+        # Permanents with a counter (battlefield order), then players with one (seat order).
+        def candidates(engine, chosen)
+          permanents = engine.state.battlefield.select { engine.object(it).counters.any? { |_, n| n.positive? } }
+          players = engine.state.players.each_index.select { engine.player_counters(it).any? { |_, n| n.positive? } }
+                          .map { Filters.player_ref(engine, it) }
+          (permanents + players - chosen).map { { "type" => "choose", "object" => it } }
+        end
+
+        def give!(engine, ctx, ref)
+          if (index = Filters.player_index(engine, ref))
+            return engine.player_counters(index).each { |kind, n| engine.add_player_counters!(index, kind, 1) if n.positive? }
+          end
+
+          obj = engine.state.objects[ref]
+          return unless obj&.zone == :battlefield
+
+          obj.counters.select { |_, n| n.positive? }.each_key { engine.add_counters!(obj, it, 1, by_player: ctx.controller) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # +N/+N until end of turn (CR 611.2, 613.4c). Affected set is locked in on resolution (611.2c).
+      # "Until your next turn" lasts until the controller's next turn begins (CR 611.2a, 500.1; see
+      # Engine::Rules#end_effects_until_turn_of!).
+      class Pump < Effect
+        DURATIONS = %w[end_of_turn until_your_next_turn].freeze
+
+        primitive :effect, :pump,
+                  description: "Each referenced creature gets +power/+toughness until end of turn (`duration: " \
+                               "\"until_your_next_turn\"`: until its controller's next turn begins). The set of " \
+                               "affected creatures is locked in when the effect starts.",
+                  rules: %w[611.2a 611.2c 613.4c 514.2 500.1],
+                  params: { "power" => "amount (may be negative, e.g. {\"times\": [\"x\", -1]} for -X)",
+                            "toughness" => "amount (may be negative)", "to" => "selector",
+                            "duration" => DURATIONS.join(" | ") },
+                  example: { "pump" => { "power" => 3, "toughness" => 3, "to" => { "target" => 0 } } }
+
+        attr_reader :duration
+
+        def self.keys = %w[power toughness to duration if]
+
+        # A signed amount: an integer, or a computed Amount ("+X/+X, where X is ...", CR 608.2h).
+        def self.signed(params, key, errors, path, **context)
+          raw = Mechanics.fetch_param(params, key)
+          raw.nil? ? Amount::Fixed.new(0) : Amount.build(raw, errors, "#{path}.#{key}", min: -1_000_000, **context)
+        end
+
+        def self.signed_text(amount) = amount.is_a?(Amount::Fixed) ? format("%+d", amount.n) : "+(#{amount})"
+
+        def setup(params, errors, path)
+          context = { targets_count: @targets_count, results_count: @results_count }
+          @power = Pump.signed(params, :power, errors, path, **context)
+          @toughness = Pump.signed(params, :toughness, errors, path, **context)
+          @duration = Mechanics.fetch_param(params, :duration) || "end_of_turn"
+          errors << "#{path}.duration: must be one of #{DURATIONS.join(", ")}" unless DURATIONS.include?(@duration)
+        end
+
+        # The fixed bonus (for display); computed bonuses are Amounts.
+        def power = @power.is_a?(Amount::Fixed) ? @power.n : @power
+        def toughness = @toughness.is_a?(Amount::Fixed) ? @toughness.n : @toughness
+
+        def to_s
+          "#{Pump.signed_text(@power)}/#{Pump.signed_text(@toughness)} until #{duration.delete_prefix("until_").tr("_", " ")} → #{to}"
+        end
+
+        # The amounts are computed once, as the effect starts (CR 608.2h, 611.2c). A noncreature it affects (an
+        # uncrewed Vehicle) gets the bonus once it's a creature this turn (CR 611.2c, 208.3).
+        def apply(engine, ctx)
+          engine.add_continuous_effect!("pump", ctx, objects(engine, ctx), "power" => @power.value(engine, ctx),
+                                                                           "toughness" => @toughness.value(engine, ctx),
+                                                                           "duration" => duration)
+        end
+      end
+    end
+  end
+end