enjine 0.1.0

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Costs
+      # "Remove N counters from among [permanents] you control" (CR 122.8 / 118.3): each choice is one
+      # counter on one permanent; they are removed as the ability becomes cast.
+      class RemoveCounters < Choosing
+        primitive :cost, :remove_counters,
+                  description: "Remove `count` counters (of kind `counter`, or any kind) from among permanents you " \
+                               "control matching `filter` (default creature), one counter per choice. Removed as " \
+                               "it becomes cast.",
+                  rules: %w[602.2b 601.2h 118.3 122.1],
+                  params: { "count" => "integer", "filter" => "filter (default creature)", "counter" => "counter name (optional)" },
+                  example: { "remove_counters" => { "count" => 3 } }
+
+        def self.keys = %w[filter count counter]
+        def self.default_filter = "creature"
+
+        def initialize(filter, count, other, params, errors, path)
+          @counter = Mechanics.fetch_param(params, :counter)
+          errors << "#{path}.counter: #{Counters.error(@counter)}" if @counter && Counters.error(@counter)
+          super
+        end
+
+        # Counters still available: [object, kind] once per counter, minus those already chosen.
+        def units(engine, object, chosen)
+          taken = chosen.map { [it["object"], it["counter"]] }
+          matching(engine, object).flat_map do |id|
+            engine.object(id).counters.flat_map do |kind, n|
+              next [] unless @counter.nil? || kind == @counter
+
+              left = n - taken.count([id, kind])
+              left.positive? ? [[id, kind]] * left : []
+            end
+          end
+        end
+
+        def payable?(engine, object) = units(engine, object, []).size >= count
+        def choice_options(engine, object, chosen) = units(engine, object, chosen).uniq.map { { object: it[0], counter: it[1] } }
+        def choose!(_engine, option) = { "object" => option[:object], "counter" => option[:counter] }
+
+        def pay_chosen!(engine, _object, entries)
+          entries.each { engine.remove_counters!(engine.object(it["object"]), it["counter"], 1) }
+        end
+
+        def to_s = "Remove #{count} #{"#{@counter} " if @counter}counters from among #{what}s you control"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Costs
+      # "Sacrifice this permanent" as a cost (CR 701.21, 602.2b).
+      class SacrificeSelf < Primitive
+        primitive :cost, :sacrifice,
+                  description: "Sacrifice the permanent the ability belongs to (it goes to its owner's graveyard).",
+                  rules: %w[701.21a 602.2b 118.3],
+                  example: "sacrifice"
+
+        INSTANCE = new.freeze
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, [], errors, path)
+          INSTANCE
+        end
+
+        def mana? = false
+        def uses_source? = true
+        # CR 701.21a, 614.17b: only a permanent on the battlefield its controller may sacrifice.
+        def payable?(engine, object) = engine.can_sacrifice?(object, object.controller)
+        def pay!(engine, object) = engine.move!(object.id, :graveyard, reason: "sacrifice")
+        def to_s = "Sacrifice this"
+      end
+
+      # "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).
+      class SacrificePermanent < Choosing
+        primitive :cost, :sacrifice_permanent,
+                  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`).",
+                  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" },
+                  example: { "sacrifice_permanent" => { "filter" => "creature", "other" => true } }
+
+        def pay_chosen!(engine, _object, entries)
+          entries.each do |entry| # still there: chosen permanents can't be sacrificed for mana (Engine::Payment)
+            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))
+            engine.move!(perm.id, :graveyard, reason: "sacrifice")
+          end
+        end
+
+        # CR 701.21a, 614.17b: only permanents their controller may sacrifice (Engine::Rules).
+        def candidates(engine, object) = matching(engine, object).select { engine.can_sacrifice?(engine.object(it), object.controller) }
+
+        def to_s = "Sacrifice #{amount_words} #{what}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Costs
+      # "Tap N untapped [permanents] you control" (CR 601.2h, 602.2b): Collation Trimatrix taps three
+      # artifact creatures. Summoning sickness doesn't matter (CR 302.6 is about {T} abilities only).
+      class TapPermanents < Choosing
+        primitive :cost, :tap_permanents,
+                  description: "Tap `count` untapped permanents you control matching `filter` (default: creature), " \
+                               "chosen while casting or activating; `other: true` excludes the source. They are " \
+                               "tapped as they are chosen; cancelling untaps them.",
+                  rules: %w[601.2h 602.2b 302.6 118.3],
+                  params: { "count" => "integer (default 1)", "filter" => "filter (default creature)",
+                            "other" => "true: not the source itself" },
+                  example: { "tap_permanents" => { "count" => 3, "filter" => { "creature" => { "types" => ["artifact"] } } } }
+
+        def self.default_filter = "creature"
+
+        def candidates(engine, object) = matching(engine, object).reject { engine.object(it).tapped }
+
+        def choose!(engine, option)
+          perm = engine.object(option[:object])
+          engine.tap!(perm)
+          { "object" => perm.id, "power" => engine.power(perm), "tapped" => true }
+        end
+
+        def to_s = "Tap #{count == 1 ? "an" : count} untapped #{what}#{"s" if count > 1} you control"
+      end
+
+      # {T}: tap this permanent (CR 107.5, 602.5a).
+      class Tap < Primitive
+        primitive :cost, :tap,
+                  description: "{T} — tap the permanent the ability belongs to. Requires it to be untapped.",
+                  rules: %w[107.5 602.5a],
+                  example: "tap"
+
+        INSTANCE = new.freeze
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, [], errors, path)
+          INSTANCE
+        end
+
+        def payable?(engine, object) = !object.tapped && !engine.summoning_sick_for_tap?(object)
+
+        def pay!(engine, object)
+          engine.tap!(object)
+        end
+
+        def mana? = false
+        def to_s = "{T}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "mana"
+
+module Enjine
+  module Mechanics
+    module Costs
+      # Waterbend [cost] (CR 701.67a): "Pay [cost]. For each generic mana in that cost, you may tap an untapped
+      # artifact or creature you control rather than pay that mana." A mana cost, so it adds to the total cost
+      # like any other (an activated ability's cost, an additional cost, kicker); while paying, the `pay_cost`
+      # option `{type: "waterbend", object: id}` taps one of those permanents for {1}, at most as many times as
+      # the waterbend cost has generic mana (CR 701.67b). Paying it is waterbending (CR 701.67c).
+      class Waterbend < ManaPayment
+        primitive :cost, :waterbend,
+                  description: "Waterbend [cost]: pay this mana cost; for each generic mana in it you may instead tap " \
+                               "an untapped artifact or creature you control (pay_cost option `{type: \"waterbend\", " \
+                               "object: id}`). Only the waterbend cost's own generic mana can be paid this way.",
+                  rules: %w[701.67a 701.67b 701.67c],
+                  params: { "(value)" => "mana cost string, e.g. \"{3}\" or \"{X}\"" },
+                  example: { "waterbend" => "{3}" }
+
+        # The generic mana tapping may pay for, with X announced.
+        def generic(x_value) = mana_cost.with_x(x_value).generic
+
+        def to_s = "Waterbend #{mana_cost}"
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/counters/kinds.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Counters
+      # Counters (CR 122). Any counter name is valid card data: a counter with no rules of its own
+      # (oil, charge, lore, ...) is just a marker that abilities can count (CR 122.1). The kinds
+      # registered here carry rules of their own:
+      #   - power/toughness counters "+X/+Y" / "-X/-Y" (CR 122.1a, layer 7c, 613.4c)
+      #   - keyword counters "flying", "hexproof", ... (CR 122.1b, layer 6, 613.1f)
+      #   - stun counters stop untapping (CR 122.1d), shield counters protect (CR 122.1c)
+      # Replacement and prevention effects of counters run through Engine#propose (CR 614, 615).
+      NAME = %r{\A(?:[+-]\d+/[+-]\d+|[a-z][a-z0-9_]*)\z}
+
+      POWER_TOUGHNESS = %r{\A([+-]\d+)/([+-]\d+)\z}
+
+      # CR 122.1b: the keywords a keyword counter can be (those the engine implements).
+      KEYWORDS = %i[flying first_strike double_strike deathtouch decayed haste hexproof indestructible lifelink menace
+                    reach trample vigilance].freeze
+
+      module_function
+
+      # "first strike" and "First-Strike" are written first_strike.
+      def normalize(name)
+        return name unless name.is_a?(String) || name.is_a?(Symbol)
+
+        POWER_TOUGHNESS.match?(name.to_s) ? name.to_s : name.to_s.downcase.tr(" -", "__")
+      end
+
+      def valid?(name) = name.is_a?(String) && NAME.match?(name)
+
+      # A counter name from card data, normalized; an invalid one is reported at `path`.
+      def parse(raw, errors, path)
+        name = normalize(raw)
+        message = error(name)
+        errors << "#{path}: #{message}" if message
+        name
+      end
+
+      # Error message for an invalid counter name, or nil.
+      def error(name)
+        return nil if valid?(name)
+
+        "must be a counter name: +X/+Y, -X/-Y or a lowercase word (e.g. +1/+1, stun, shield, oil)"
+      end
+
+      # [power delta, toughness delta] from all power/toughness counters (CR 122.1a, 613.4c).
+      def power_toughness(counters)
+        counters.each_with_object([0, 0]) do |(name, n), delta|
+          m = POWER_TOUGHNESS.match(name) or next
+          delta[0] += Integer(m[1]) * n
+          delta[1] += Integer(m[2]) * n
+        end
+      end
+
+      # Keywords granted by keyword counters (CR 122.1b).
+      def keywords(counters)
+        counters.filter_map do |name, n|
+          name.to_sym if n.positive? && KEYWORDS.include?(name.to_sym) && Enjine.registry.fetch(:keyword, name)
+        end
+      end
+
+      def any?(counters) = counters.any? { |_, n| n.positive? }
+
+      # Whether `name` is a keyword counter (CR 122.1b).
+      def keyword?(name) = KEYWORDS.include?(name.to_s.to_sym)
+
+      # Replacement / prevention effects created by the counters on the object a proposal affects.
+      def replace!(engine, proposal)
+        id = proposal.data[proposal.kind == "damage" ? "target" : "object"]
+        obj = id && engine.state.objects[id]
+        return unless obj && obj.zone == :battlefield
+
+        if proposal.kind == "damage" && engine.damage_batch&.include?(obj.id) # its shield already applied (CR 615.12a)
+          proposal.data["amount"] = 0 unless proposal.data["unpreventable"]
+          return
+        end
+
+        obj.counters.each do |name, n|
+          kind = Enjine.registry.fetch(:counter, name)
+          next unless n.positive? && kind.respond_to?(:replace!) && !proposal.applied.include?("counter:#{name}")
+
+          proposal.applied << "counter:#{name}" # CR 614.5: each replacement applies once
+          kind.replace!(engine, obj, proposal)
+        end
+      end
+
+      # A counter kind with rules (documentation and behavior).
+      class Kind < Primitive
+        def self.build(_params, _errors, _path, **) = self
+      end
+
+      # +1/+1 counters (CR 122.1a). Annihilate with -1/-1 counters as a state-based action (CR 704.5q).
+      class PlusOne < Kind
+        primitive :counter, :"+1/+1",
+                  description: "Adds 1 to power and toughness (layer 7c). Any +X/+Y or -X/-Y counter works the same " \
+                               "way. If a permanent has both +1/+1 and -1/-1 counters, N of each are removed as a " \
+                               "state-based action (N = the smaller count).",
+                  rules: %w[122.1a 122.3 613.4c 704.5q],
+                  example: { "add_counters" => { "counter" => "+1/+1", "amount" => 1, "to" => "self" } }
+      end
+
+      # -1/-1 counters (CR 122.1a).
+      class MinusOne < Kind
+        primitive :counter, :"-1/-1", description: "Subtracts 1 from power and toughness (layer 7c).",
+                                      rules: %w[122.1a 122.3 613.4c 704.5q],
+                                      example: { "add_counters" => { "counter" => "-1/-1", "amount" => 1, "to" => { "target" => 0 } } }
+      end
+
+      # Loyalty counters (CR 122.1e, 306.5b).
+      class Loyalty < Kind
+        primitive :counter, :loyalty, description: "A planeswalker's loyalty; at 0 it is put into its owner's graveyard.",
+                                      rules: %w[122.1e 306.5b 704.5i],
+                                      example: { "add_counters" => { "counter" => "loyalty", "amount" => 1, "to" => "self" } }
+      end
+
+      # Keyword counters (CR 122.1b). Registered once under the name "keyword" for documentation;
+      # the counter itself is named after its keyword ("flying", "hexproof", "first_strike", ...).
+      class KeywordCounter < Kind
+        primitive :counter, :keyword,
+                  description: "A counter named after a keyword (#{KEYWORDS.join(", ")}) gives the permanent that " \
+                               "keyword (layer 6). Write the keyword itself as the counter name.",
+                  rules: %w[122.1b 613.1f],
+                  example: { "add_counters" => { "counter" => "hexproof", "amount" => 1, "to" => "self" } }
+      end
+
+      # Stun counters (CR 122.1d): "If a permanent with a stun counter on it would become untapped,
+      # instead remove a stun counter from it."
+      class Stun < Kind
+        primitive :counter, :stun,
+                  description: "If the permanent would become untapped (untap step or an effect), instead one stun " \
+                               "counter is removed from it.",
+                  rules: %w[122.1d 502.3 701.26b],
+                  example: { "add_counters" => { "counter" => "stun", "amount" => 1, "to" => { "target" => 0 } } }
+
+        def self.replace!(engine, obj, proposal)
+          return unless proposal.kind == "untap"
+
+          proposal.data["cancelled"] = true
+          engine.remove_counters!(obj, "stun", 1)
+        end
+      end
+
+      # Finality counters (CR 122.1h): "If this permanent would be put into a graveyard from the
+      # battlefield, exile it instead."
+      class Finality < Kind
+        primitive :counter, :finality,
+                  description: "If the permanent would be put into a graveyard from the battlefield, it is exiled instead.",
+                  rules: %w[122.1h 614.1a],
+                  example: { "enters_with_counters" => { "counters" => { "finality" => 1 } } }
+
+        def self.replace!(_engine, _obj, proposal)
+          proposal.data["to"] = :exile if proposal.kind == "zone_change" && proposal.data["to"] == :graveyard
+        end
+      end
+
+      # Shield counters (CR 122.1c): one replacement effect ("if it would be destroyed as the result of
+      # an effect, instead remove a shield counter") and one prevention effect ("if damage would be dealt
+      # to it, prevent that damage and remove a shield counter").
+      class Shield < Kind
+        primitive :counter, :shield,
+                  description: "If the permanent would be destroyed by an effect, instead remove a shield counter. If " \
+                               "damage would be dealt to it, prevent it and remove a shield counter (simultaneous " \
+                               "damage, such as combat damage, removes only one).",
+                  rules: %w[122.1c 614.1a 615.1a 701.8b],
+                  example: { "add_counters" => { "counter" => "shield", "amount" => 1, "to" => { "target" => 0 } } }
+
+        def self.replace!(engine, obj, proposal)
+          case proposal.kind
+          when "zone_change"
+            return unless proposal.data["reason"] == "destroy" # CR 701.8b: lethal-damage SBAs aren't "an effect"
+
+            proposal.data["cancelled"] = true
+            engine.remove_counters!(obj, "shield", 1)
+          when "damage"
+            prevent_damage!(engine, obj, proposal)
+          end
+        end
+
+        # CR 615.1a. Damage dealt at the same time by several sources is one event: one counter. Damage that
+        # can't be prevented is dealt, and the counter is still removed (CR 615.12).
+        def self.prevent_damage!(engine, obj, proposal)
+          proposal.data["amount"] = 0 unless proposal.data["unpreventable"]
+          engine.damage_batch&.push(obj.id)
+          engine.remove_counters!(obj, "shield", 1)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # "Until end of turn, they become Warriors in addition to their other types." (CR 613.1d, 205.1b)
+      class AddSubtypes < Effect
+        primitive :effect, :add_subtypes,
+                  description: "Each referenced permanent gets the `subtypes` in addition to its other types until " \
+                               "end of turn (layer 4).",
+                  rules: %w[613.1d 205.1b 611.2a 611.2c],
+                  params: { "subtypes" => "list of lowercase subtypes", "to" => "selector" },
+                  example: { "add_subtypes" => { "subtypes" => ["warrior"], "to" => { "target" => 0 } } }
+
+        attr_reader :subtypes
+
+        def self.keys = %w[subtypes to if]
+
+        def setup(params, errors, path)
+          @subtypes = Mechanics.list_param(params, :subtypes, errors, path).map(&:to_s)
+          ok = !@subtypes.empty? && @subtypes.all? { CardDefinition::SUBTYPE_FORMAT.match?(it) }
+          errors << "#{path}.subtypes: must be a non-empty list of lowercase subtypes" unless ok
+        end
+
+        def apply(engine, ctx) = engine.add_continuous_effect!("add_subtypes", ctx, objects(engine, ctx), "subtypes" => subtypes)
+        def to_s = "becomes #{subtypes.join(" ")} in addition until end of turn → #{to}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Airbend (CR 701.65a): "exile those objects. For each card exiled this way, for as long as it remains
+      # exiled, its owner may cast it by paying {2} rather than paying its mana cost." The permanents and spells
+      # are the referenced ones (usually targets); each exiled card gets a permission for its owner whose
+      # alternative cost is {2} (CR 118.9, Engine::Permissions). A token or a copy of a spell ceases to exist
+      # (CR 111.7, 707.10a), so it can't be cast. Exiling one or more objects this way is airbending (CR 701.65b).
+      class Airbend < ZoneEffect
+        COST = "{2}"
+
+        primitive :effect, :airbend,
+                  description: "Airbend: exile each referenced permanent or spell; for as long as each card stays " \
+                               "exiled, its owner may cast it by paying {2} rather than its mana cost (cast option " \
+                               "`via: \"effect:<n>\"`). The exiled cards are the effect's results.",
+                  rules: %w[701.65a 701.65b 118.9 601.2f],
+                  params: { "to" => "selector of permanents and/or spells" },
+                  example: { "airbend" => { "to" => { "target" => 0 } } }
+
+        def self.zone = :exile
+        def self.reason = "airbend"
+        def self.from_zones = %i[battlefield stack]
+
+        def to_s = "airbend → #{to}"
+
+        def apply(engine, ctx)
+          moved = movable(engine, ctx).filter_map { move(engine, ctx, it) }
+          return if moved.empty?
+
+          moved.select { it.zone == :exile }.group_by(&:owner).each do |owner, cards|
+            engine.grant_play_permission!(owner, cards.map(&:id), duration: "while_exiled", play: "cast",
+                                                                  alt: { "cost" => COST })
+          end
+          engine.emit Events::KeywordAction.new(player: engine.name(ctx.controller), action: "airbend", amount: moved.size)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # "If you don't control a [kind of permanent], create one as a token. Choose one you control. Put N
+      # [counters] on it.": the shared shape of amass (CR 701.47a) and empower Jace (CR 701.71a). The choice
+      # is an `effect_choice` only when there is more than one candidate. The chosen permanent is the
+      # effect's result ("the amassed Army", CR 701.47c); a token just created already is.
+      class ChooseOrCreate < ChoiceEffect
+        def self.keys = %w[amount if]
+        def self.default_to = "you"
+
+        def run(engine, ctx, locals)
+          return :done unless locals.key?("n") || condition.nil? || condition.true?(engine, ctx)
+
+          unless locals.key?("n")
+            locals["n"] = amount_for(engine, ctx)
+            locals["created"] = candidates(engine, ctx.controller).empty?
+            engine.create_token!(token, ctx.controller) if locals["created"]
+          end
+          options = candidates(engine, ctx.controller)
+          answer = answers(locals).first
+          if answer.nil? && options.size > 1
+            return ask(engine, locals, ctx.controller, "#{self}: choose one",
+                       options.map { { "type" => "choose", "object" => it } })
+          end
+          chosen = answer ? answer["object"] : options.first
+          finish(engine, ctx, chosen, locals) if chosen
+          :done
+        end
+
+        def created_tokens = [token]
+
+        private
+
+        def candidates(engine, index)
+          engine.state.battlefield.select { engine.object(it).controller == index && candidate?(engine, engine.object(it)) }
+        end
+
+        def finish(engine, ctx, chosen, locals)
+          perm = engine.object(chosen)
+          engine.record_result!(chosen) unless locals["created"]
+          engine.add_counters!(perm, counter, locals["n"], by_player: ctx.controller)
+        end
+      end
+
+      # Amass [subtype] N (CR 701.47a): if you don't control an Army creature, create a 0/0 black [subtype]
+      # Army creature token; choose an Army creature you control; put N +1/+1 counters on it; if it isn't a
+      # [subtype], it becomes one in addition to its other types (layer 4, for as long as it stays).
+      class Amass < ChooseOrCreate
+        primitive :effect, :amass,
+                  description: "Amass `subtype` `amount`: if you control no Army creature, create a 0/0 black " \
+                               "[subtype] Army creature token; then put `amount` +1/+1 counters on an Army creature " \
+                               "you control (chosen if there are several), which becomes a [subtype] too.",
+                  rules: %w[701.47a 701.47b 701.47c 613.1d],
+                  params: { "subtype" => "lowercase creature type, e.g. \"orc\"", "amount" => "amount" },
+                  example: { "amass" => { "subtype" => "orc", "amount" => 2 } }
+
+        attr_reader :subtype, :token
+
+        def self.keys = %w[subtype amount if]
+
+        def setup(params, errors, path)
+          @subtype = Mechanics.fetch_param(params, :subtype).to_s
+          unless CardDefinition::SUBTYPE_FORMAT.match?(@subtype) && @subtype != "army"
+            errors << "#{path}.subtype: must be a lowercase creature type other than army"
+            @subtype = "zombie"
+          end
+          @token = CardDefinition.token({ "name" => "#{@subtype.split("_").map(&:capitalize).join(" ")} Army",
+                                          "types" => ["creature"], "subtypes" => [@subtype, "army"], "colors" => ["B"],
+                                          "power" => 0, "toughness" => 0 })
+        end
+
+        def counter = "+1/+1"
+        def to_s = "amass #{subtype.tr("_", " ")} #{amount}"
+
+        private
+
+        def candidate?(engine, perm)
+          chars = engine.chars(perm)
+          chars.creature? && chars.subtypes.include?(:army)
+        end
+
+        def finish(engine, ctx, chosen, locals)
+          super
+          return if engine.chars(chosen).subtypes.include?(subtype.to_sym)
+
+          engine.add_continuous_effect!("add_subtypes", ctx, [chosen], "subtypes" => [subtype], "duration" => "permanent")
+        end
+      end
+
+      # Empower Jace N (CR 701.71a): if you don't control a Jace planeswalker token, create a blue Jace
+      # planeswalker token with 0 loyalty, "[-1]: Surveil 1" and "[-3]: Draw a card"; choose a Jace
+      # planeswalker token you control; put N loyalty counters on it. State-based actions aren't checked
+      # while the effect resolves, so the new token gets its counters first (CR 704.3).
+      class EmpowerJace < ChooseOrCreate
+        primitive :effect, :empower_jace,
+                  description: "Empower Jace `amount`: if you control no Jace planeswalker token, create a blue Jace " \
+                               "planeswalker token (0 loyalty; -1: surveil 1; -3: draw a card); then put `amount` " \
+                               "loyalty counters on a Jace planeswalker token you control.",
+                  rules: %w[701.71a 704.3],
+                  params: { "amount" => "amount" },
+                  example: { "empower_jace" => { "amount" => 2 } }
+
+        TOKEN = { "name" => "Jace", "types" => ["planeswalker"], "subtypes" => ["jace"], "colors" => ["U"], "loyalty" => 0,
+                  "abilities" => [{ "loyalty" => { "cost" => -1, "effects" => [{ "surveil" => { "amount" => 1 } }] } },
+                                  { "loyalty" => { "cost" => -3, "effects" => [{ "draw" => { "amount" => 1 } }] } }] }.freeze
+
+        def token = EmpowerJace.token
+        def self.token = @token ||= CardDefinition.token(TOKEN)
+        def counter = "loyalty"
+        def to_s = "empower Jace #{amount}"
+
+        private
+
+        def candidate?(engine, perm)
+          chars = engine.chars(perm)
+          engine.token?(perm) && chars.planeswalker? && chars.subtypes.include?(:jace)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Assimilate (CR 701.72). A permanent: gain control of it and put a
+      # +1/+1 counter on it (701.72a). A permanent card in another zone: put it onto the battlefield under
+      # your control with a +1/+1 counter (701.72b). Either way it's a Borg artifact creature from then on:
+      # it keeps its other card types and subtypes except its creature types (CR 205.1b).
+      #
+      # `choose: true` assimilates one of the referenced cards, chosen by the controller as it resolves
+      # ("assimilate a creature card exiled with it", 701.72c, 607.2a); `for` keeps only cards matching a
+      # card spec. What it put onto the battlefield is its result, so a later effect can say "if you can't".
+      class Assimilate < ChoiceEffect
+        primitive :effect, :assimilate,
+                  description: "Assimilate each referenced permanent or permanent card: you gain control of it (or " \
+                               "put it onto the battlefield under your control) with a +1/+1 counter, and it " \
+                               "becomes a Borg artifact creature while it stays on the battlefield. `for`: only cards " \
+                               "matching a card spec; `choose: true`: you choose one of them.",
+                  rules: %w[701.72a 701.72b 701.72c 607.2a 205.1b 613.1b 613.1d 614.12a],
+                  params: { "to" => "selector (permanents, or a target card in a graveyard, or \"exiled_with\")",
+                            "for" => "card spec (default: any)", "choose" => "boolean" },
+                  example: { "assimilate" => { "to" => { "target" => 0 } } }
+
+        def self.keys = %w[to for choose if]
+
+        def setup(params, errors, path)
+          raw = Mechanics.fetch_param(params, :for)
+          @spec = raw && CardSpec.build(raw, errors, "#{path}.for")
+          @choose = Mechanics.flag_param(params, "choose", errors, path)
+        end
+
+        def to_s = "assimilate#{" one" if @choose}#{" #{@spec}" if @spec} → #{to}"
+
+        def run(engine, ctx, locals)
+          return :done unless locals.key?("refs") || condition.nil? || condition.true?(engine, ctx)
+
+          refs = (locals["refs"] ||= candidates(engine, ctx))
+          unless locals.key?("chosen")
+            return ask_which(engine, ctx, locals, refs) if @choose && refs.size > 1 && answers(locals).empty?
+
+            picked = answers(locals).map { it["object"] }
+            picked = refs.first(1) if picked.empty?
+            locals["chosen"] = @choose ? picked : refs
+          end
+          chosen = locals["chosen"].select { engine.state.objects.key?(it) }
+          entering = chosen.reject { engine.object(it).zone == :battlefield }.map { [it, ctx.controller] }
+          return :wait if engine.ask_entering_choices!(locals, entering) == :wait
+
+          chosen.each do |id|
+            engine.assimilate!(id, ctx.controller, ctx, enters: engine.with_entering_answer(locals, id, ctx.controller, nil))
+          end
+          :done
+        end
+
+        private
+
+        def candidates(engine, ctx)
+          refs(engine, ctx).select do |id|
+            obj = engine.state.objects[id]
+            obj && !obj.ability? && (@spec.nil? || @spec.match?(engine, obj, ctx))
+          end
+        end
+
+        def ask_which(engine, ctx, locals, refs)
+          ask(engine, locals, ctx.controller, "Choose a card to assimilate",
+              refs.map { { "type" => "assimilate", "object" => it } })
+        end
+      end
+    end
+  end
+end