enjine 0.1.0

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

@@ -0,0 +1,370 @@
+# frozen_string_literal: true
+
+require_relative "../copy_except"
+require_relative "../abilities/play_permissions"
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Effects that copy something named by `of` (CR 707.1). "of": "self" is the source in any zone,
+      # or, when it has left its zone (a card exiled from a graveyard to pay the cost), its card.
+      module CopyOf
+        def setup_of(params, errors, path)
+          raw = Mechanics.fetch_param(params, :of)
+          return (errors << "#{path}.of: required") && nil if raw.nil?
+
+          Selector.build(raw, errors, "#{path}.of", targets_count: @targets_count, results_count: @results_count)
+        end
+
+        def of_refs(engine, ctx)
+          return [] unless @of
+          return @of.resolve(engine, ctx) unless @of.kind == :self
+
+          [ctx.source].compact
+        end
+
+        # The copiable values [card, except] of each referenced object (CR 707.2). An object that left its
+        # zone since is used as it last existed (CR 608.2h).
+        def copy_values(engine, ctx)
+          of_refs(engine, ctx).filter_map do |ref|
+            obj = engine.state.objects[ref]
+            next engine.copiable_values(obj) if obj && !obj.ability?
+
+            lki = engine.resolving_last_known(ref)
+            next [lki["card"], lki["except"] || {}] if lki&.key?("card")
+
+            source_card(engine, ctx) if @of.kind == :self
+          end
+        end
+
+        def source_card(engine, ctx)
+          stacked = engine.state.objects[ctx.object]
+          stacked&.ability? ? [stacked.card, {}] : nil
+        end
+      end
+
+      # Choosing new targets for a spell or ability on the stack, one target at a time: keep the old one (even if
+      # it's illegal now) or pick a legal new one (CR 115.7d, 707.10c). `legal_for`: whose targets they are
+      # (legality, CR 115.7); `chooser`: who decides.
+      module NewTargets
+        def choose_new_targets(engine, spell, legal_for, locals, chooser: legal_for)
+          old = spell.targets || []
+          specs = engine.resolving_ability(spell)&.targets_for(spell.modes || [], kicked: spell.memory.key?("kicked_with")) || []
+          slots = engine.target_slots(old, specs) # each target of a counted slot in turn; same number (CR 707.10c)
+          chosen = answers(locals).map { it["target"] }
+          return engine.regroup_targets(chosen, old) if chosen.size >= slots.size
+
+          i = chosen.size
+          current, spec = slots[i]
+          keep = [{ "type" => "target", "target" => current }]
+          others = spec ? new_target_choices(engine, spec, legal_for, spell, current) : []
+          ask(engine, locals, chooser, "Choose target ##{i + 1} for #{engine.catalog.fetch(spell.card).name}", keep + others)
+        end
+
+        private
+
+        def new_target_choices(engine, spec, controller, spell, current)
+          source = spell.ability? ? spell.source : nil # an ability's copy has the same source (CR 707.10b)
+          spec.candidates_for(engine, controller, source).filter_map do |ref|
+            next if ref == current || ref == spell.id || !engine.targetable?(ref, controller, source, targeter: source || spell.id)
+
+            { "type" => "target", "target" => ref }
+          end
+        end
+      end
+
+      # "Create a token that's a copy of ..." (CR 707.8, 111.1).
+      class CreateTokenCopy < Effect
+        include CopyOf
+
+        primitive :effect, :create_token_copy,
+                  description: "For each object `of` refers to (a permanent, a card in any zone, or the source with " \
+                               "\"self\"), the referenced players (default: you) each create `amount` tokens that " \
+                               "are copies of it: its copiable values (its card as modified by other copy effects, " \
+                               "not counters, status or other effects), with the `except` modifications. The tokens " \
+                               "are the effect's result, for later effects such as granting haste or a delayed " \
+                               "sacrifice.",
+                  rules: %w[707.2 707.8 707.9a 707.9b 111.1 614.1c],
+                  params: { "of" => "selector (what to copy)", "amount" => "amount (default 1)", "tapped" => "boolean",
+                            "except" => CopyExcept::PARAM, "to" => "selector (default \"you\")" },
+                  example: { "create_token_copy" => { "of" => { "target" => 0 }, "except" => { "legendary" => false } } }
+
+        def self.keys = %w[of amount tapped except to 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 setup(params, errors, path)
+          @of = setup_of(params, errors, path)
+          @tapped = Mechanics.flag_param(params, :tapped, errors, path)
+          @except = CopyExcept.build(Mechanics.fetch_param(params, :except), errors, "#{path}.except")
+        end
+
+        def to_s
+          "create #{amount} token cop#{amount == 1 ? "y" : "ies"} of #{@of}#{" tapped" if @tapped}" \
+            "#{CopyExcept.to_s(@except)} → #{to}"
+        end
+
+        def apply(engine, ctx)
+          n = amount_for(engine, ctx)
+          values = copy_values(engine, ctx)
+          players(engine, ctx).each do |index|
+            values.each do |card, except|
+              merged = [card, Engine::Copies.merge_except(except, @except)]
+              n.times { engine.create_token_copy!(merged, index, tapped: @tapped) }
+            end
+          end
+        end
+      end
+
+      # "... becomes a copy of ..." (CR 707.4, 613.2a), for a duration.
+      class BecomeCopy < Effect
+        include CopyOf
+
+        DURATIONS = %w[end_of_turn permanent].freeze
+
+        primitive :effect, :become_copy,
+                  description: "Each referenced permanent becomes a copy of the (first) object `of` refers to, with the " \
+                               "`except` modifications, until end of turn (default) or for as long as it stays on the " \
+                               "battlefield (`duration: \"permanent\"`). It keeps its counters, status and other " \
+                               "effects; nothing enters or leaves, so no enter or leave abilities trigger. Several copy " \
+                               "effects apply in timestamp order.",
+                  rules: %w[707.2 707.4 613.2a 613.7 611.2a 514.2],
+                  params: { "to" => "selector (the permanents that become copies)", "of" => "selector (what they copy)",
+                            "except" => CopyExcept::PARAM, "duration" => DURATIONS.join(" | ") },
+                  example: { "become_copy" => { "to" => "self", "of" => { "target" => 0 } } }
+
+        def self.keys = %w[of except duration to if]
+
+        def setup(params, errors, path)
+          @of = setup_of(params, errors, path)
+          @except = CopyExcept.build(Mechanics.fetch_param(params, :except), errors, "#{path}.except")
+          @duration = Mechanics.fetch_param(params, :duration) || "end_of_turn"
+          errors << "#{path}.duration: must be one of #{DURATIONS.join(", ")}" unless DURATIONS.include?(@duration)
+        end
+
+        def to_s = "becomes a copy of #{@of}#{CopyExcept.to_s(@except)} (#{@duration.tr("_", " ")}) → #{to}"
+
+        def apply(engine, ctx)
+          first = copy_values(engine, ctx).first or return
+          values = [first[0], Engine::Copies.merge_except(first[1], @except)]
+          objects(engine, ctx).each { engine.become_copy!(engine.object(it), values, duration: @duration) }
+        end
+      end
+
+      # "Copy [spell]" / "copy target activated or triggered ability" (CR 707.10): the copy goes on the stack
+      # with the same choices; it isn't cast or activated.
+      class CopySpell < ChoiceEffect
+        include CopyOf
+        include NewTargets
+
+        primitive :effect, :copy_spell,
+                  description: "Copy each spell or ability on the stack `of` refers to (\"self\": the spell this ability " \
+                               "or spell belongs to; a `stack_ability` target: an activated or triggered ability) " \
+                               "`amount` times. The copies are put on the stack under the referenced player's " \
+                               "control (default: you) with the same modes, X, kicker and targets; they aren't cast " \
+                               "or activated, and an ability's copy has the same source. With `new_targets: true` " \
+                               "the controller may choose new targets for each copy. A copy of a permanent spell " \
+                               "becomes a token as it resolves. `except`: the copies have these differences (e.g. " \
+                               "{\"keywords\": [\"wither\"]}: \"the copy gains wither\").",
+                  rules: %w[707.10 707.10a 707.10b 707.10c 707.10f 608.3f],
+                  params: { "of" => "selector (spells or abilities on the stack)", "amount" => "amount (default 1)",
+                            "new_targets" => "boolean", "to" => "selector (default \"you\")", "except" => CopyExcept::PARAM },
+                  example: { "copy_spell" => { "of" => "self" } }
+
+        def self.keys = %w[of amount new_targets except to 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 setup(params, errors, path)
+          @of = setup_of(params, errors, path)
+          @new_targets = Mechanics.flag_param(params, :new_targets, errors, path)
+          @except = CopyExcept.build(Mechanics.fetch_param(params, :except), errors, "#{path}.except")
+        end
+
+        def to_s = "copy #{@of}#{" #{amount} times" if amount != 1}#{" (new targets)" if @new_targets} → #{to}"
+
+        # Each copy is planned as [spell, controller]; with new targets, its targets are chosen one at a
+        # time (keep the old one or pick a legal new one, CR 707.10c) before it's put on the stack.
+        def run(engine, ctx, locals)
+          return :done unless locals["plan"] || condition.nil? || condition.true?(engine, ctx)
+
+          locals["plan"] ||= plan(engine, ctx)
+          while (spell_id, controller = locals["plan"].first)
+            spell = engine.state.objects[spell_id]
+            if spell&.zone == :stack
+              targets = @new_targets ? choose_new_targets(engine, spell, controller, locals) : spell.targets&.dup
+              return :wait if targets == :wait
+
+              engine.copy_spell!(spell, controller, targets, except: @except)
+            end
+            locals["plan"].shift
+            locals.delete("answers")
+            locals.delete("asked")
+          end
+          :done
+        end
+
+        private
+
+        def plan(engine, ctx)
+          n = amount_for(engine, ctx)
+          spells = of_refs(engine, ctx).select { engine.state.objects[it]&.zone == :stack }
+          players(engine, ctx).flat_map { |index| spells.flat_map { |id| Array.new(n) { [id, index] } } }
+        end
+      end
+
+      # "You may choose new targets for that spell" (CR 115.7d): the controller of this effect goes through each
+      # target of the spell or ability `of` refers to, keeping it or choosing a new legal one (legal for the spell's
+      # controller). Only the final set of targets is checked (CR 115.7e).
+      class ChooseNewTargets < ChoiceEffect
+        include CopyOf
+        include NewTargets
+
+        primitive :effect, :choose_new_targets,
+                  description: "You may choose new targets for each spell or ability on the stack `of` refers to (e.g. " \
+                               "{\"triggering\": \"object\"}: \"that spell\"): for each target, keep it or pick another " \
+                               "legal target for that spell.",
+                  rules: %w[115.7 115.7d 115.7e],
+                  params: { "of" => "selector (spells or abilities on the stack)" },
+                  example: { "choose_new_targets" => { "of" => { "triggering" => "object" } } }
+
+        def self.keys = %w[of if]
+        def self.default_to = "you"
+        def setup(params, errors, path) = @of = setup_of(params, errors, path)
+        def to_s = "you may choose new targets for #{@of}"
+
+        def run(engine, ctx, locals)
+          return :done unless locals["spells"] || condition.nil? || condition.true?(engine, ctx)
+
+          locals["spells"] ||= of_refs(engine, ctx).select { engine.state.objects[it]&.zone == :stack }
+          while (id = locals["spells"].first)
+            spell = engine.state.objects[id]
+            if spell&.zone == :stack && !Array(spell.targets).flatten.compact.empty?
+              targets = choose_new_targets(engine, spell, spell.controller, locals, chooser: ctx.controller)
+              return :wait if targets == :wait
+
+              engine.change_targets!(spell, targets, ctx.controller)
+            end
+            locals["spells"].shift
+            locals.delete("answers")
+          end
+          :done
+        end
+      end
+
+      # "Copy that card" / "create a copy of this card" (CR 707.12): copies of cards, in the zone the card is in.
+      class CopyCard < Effect
+        include CopyOf
+
+        primitive :effect, :copy_card,
+                  description: "Create `amount` copies of each card `of` refers to (\"self\": the source card), in the zone " \
+                               "that card is in, owned by you. They are the effect's result, e.g. for `cast_free` or " \
+                               "`cast`. A card copy ceases to exist if it is anywhere but the stack or the " \
+                               "battlefield (so one that isn't cast now is gone at the next state-based-action check).",
+                  rules: %w[707.12 707.12a 707.10a 704.5d],
+                  params: { "of" => "selector (cards)", "amount" => "amount (default 1)" },
+                  example: { "copy_card" => { "of" => { "result" => 0 }, "amount" => 2 } }
+
+        def self.keys = %w[of 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 setup(params, errors, path) = @of = setup_of(params, errors, path)
+        def to_s = "copy #{@of}#{" #{amount} times" if amount != 1}"
+
+        def apply(engine, ctx)
+          n = amount_for(engine, ctx)
+          of_refs(engine, ctx).each do |ref|
+            obj = engine.state.objects[ref]
+            next unless obj && !obj.ability? && obj.zone != :battlefield
+
+            n.times { engine.create_card_copy!(engine.copiable_values(obj), ctx.controller, obj.zone) }
+          end
+        end
+      end
+
+      # "You may cast [it]" while the effect resolves, paying its costs (CR 608.2g, 707.12, 601.2a): like
+      # cast_free, but the spell's mana cost is paid as usual.
+      class Cast < CastFree
+        primitive :effect, :cast,
+                  description: "The controller may cast referenced cards (or card copies) now, while this resolves, " \
+                               "paying their costs; timing restrictions don't apply. `to`, `for`, `not_types`, " \
+                               "`max_mana_value`, `count`, `exile_instead` and `any_mana_type` work as for `cast_free`.",
+                  rules: %w[608.2g 707.12 707.12a 601.2a 601.2f],
+                  params: { "to" => "selector", "for" => "card spec", "not_types" => "list of card types",
+                            "max_mana_value" => "amount", "count" => "1 or \"any\"",
+                            "exile_instead" => "true or a card spec (as for cast_free)",
+                            "any_mana_type" => "boolean: mana of any type can be spent to cast it (CR 609.4b)" },
+                  example: { "cast" => { "to" => { "result" => 0 } } }
+
+        def to_s = super.sub(" free", "")
+        def via = "resolving"
+        def prompt = "You may cast a spell"
+        def castable_now?(engine, index, id) = engine.castable_while_resolving?(index, id, any_mana_type: @riders["any_mana_type"])
+      end
+
+      # A card or permanent gains an ability (CR 113.6b, 611.2): "that card gains '...'". The ability lives
+      # in this card's data (its reference "granted:<card>:<ref>"); it lasts while the object stays in its
+      # zone, or until end of turn.
+      class GrantAbility < Effect
+        DURATIONS = %w[permanent end_of_turn].freeze
+
+        primitive :effect, :grant_ability,
+                  description: "Each referenced object (a permanent, or a card in any zone, e.g. an exiled card) gains " \
+                               "`ability` (any ability entry) for as long as it stays in its zone (default) or until " \
+                               "end of turn. `for` (a card spec) keeps only matching objects (\"that nonland card\"). " \
+                               "An activated ability with `zone` works from that zone (\"activate only if this card is " \
+                               "exiled\").",
+                  rules: %w[113.6b 611.2a 613.1f],
+                  params: { "ability" => "an ability", "to" => "selector", "for" => "card spec",
+                            "duration" => DURATIONS.join(" | ") },
+                  example: { "grant_ability" => { "to" => { "result" => 0 },
+                                                  "ability" => { "activated" => { "cost" => [{ "mana" => "{1}" }],
+                                                                                  "zone" => "exile",
+                                                                                  "effects" => [{ "draw" => { "amount" => 1 } }] } } } }
+
+        attr_reader :ref, :granted_ability
+
+        def self.keys = %w[ability duration for to if]
+
+        def setup(params, errors, path)
+          @ref = "grant:#{path}"
+          @for = CardSpec.build(Mechanics.fetch_param(params, :for), errors, "#{path}.for")
+          raw = Mechanics.fetch_param(params, :ability)
+          @granted_ability = if raw.nil?
+                               (errors << "#{path}.ability: required") && nil
+                             else
+                               Mechanics.build_entry(:ability, raw, errors,
+                                                     "#{path}.ability")
+                             end
+          @duration = Mechanics.fetch_param(params, :duration) || "permanent"
+          errors << "#{path}.duration: must be one of #{DURATIONS.join(", ")}" unless DURATIONS.include?(@duration)
+        end
+
+        def nested_effects = @granted_ability.respond_to?(:effects) ? @granted_ability.effects : []
+        def to_s = "gains \"#{@granted_ability}\"#{" until end of turn" if @duration == "end_of_turn"} → #{to}"
+
+        def apply(engine, ctx)
+          card = engine.state.objects[ctx.object]&.card or return
+          affected = refs(engine, ctx).select { (obj = engine.state.objects[it]) && @for.match?(engine, obj) }
+          engine.grant_card_ability!(ctx, affected, card, @ref, @duration) unless affected.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Counter a spell or ability (CR 701.6).
+      class CounterSpell < Effect
+        primitive :effect, :counter, description: "Counter each referenced spell or ability: a spell leaves the " \
+                                                  "stack for its owner's graveyard without resolving, an ability " \
+                                                  "ceases to exist. A spell that can't be countered stays.",
+                                     rules: %w[701.6a 701.6b 101.2], params: { "to" => "selector" },
+                                     example: { "counter" => { "to" => { "target" => 0 } } }
+        def self.keys = %w[to if]
+
+        def apply(engine, ctx)
+          refs(engine, ctx).each { engine.counter!(it) if engine.state.stack.include?(it) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Put counters on permanents or players (CR 122).
+      class AddCounters < Effect
+        primitive :effect, :add_counters,
+                  description: "Put `amount` counters named `counter` on each referenced permanent or player. Any " \
+                               "counter name works (+1/+1, -1/-1, loyalty, stun, shield, oil, a keyword, ...; on a " \
+                               "player poison, experience, ...); see docs/reference/counters.md for the ones with " \
+                               "rules. A player with ten or more poison counters loses the game.",
+                  rules: %w[122.1 122.1f 122.6 613.4c 704.5c],
+                  params: { "counter" => "counter name (+X/+Y, -X/-Y or a lowercase word)", "amount" => "integer",
+                            "to" => "selector" },
+                  example: { "add_counters" => { "counter" => "+1/+1", "amount" => 1,
+                                                 "to" => { "each" => "creature", "controller" => "you" } } }
+
+        attr_reader :counter
+
+        def self.keys = %w[counter amount to if]
+
+        def setup(params, errors, path)
+          @counter = Counters.parse(Mechanics.fetch_param(params, :counter), errors, "#{path}.counter")
+        end
+
+        def to_s = "#{amount} #{counter} counter(s) → #{to}"
+
+        def apply(engine, ctx)
+          n = amount_for(engine, ctx)
+          objects(engine, ctx).each { engine.add_counters!(engine.object(it), counter, n, by_player: ctx.controller) }
+          players(engine, ctx).each { engine.add_player_counters!(it, counter, n) } # "that player gets two poison counters"
+        end
+      end
+
+      # "Remove two +1/+1 counters from target creature." (CR 122.8)
+      class RemoveCounters < Effect
+        primitive :effect, :remove_counters,
+                  description: "Remove up to `amount` counters named `counter` from each referenced permanent.",
+                  rules: %w[122.8],
+                  params: { "counter" => "counter name", "amount" => "amount", "to" => "selector" },
+                  example: { "remove_counters" => { "counter" => "+1/+1", "amount" => 2, "to" => { "target" => 0 } } }
+
+        attr_reader :counter
+
+        def self.keys = %w[counter amount to if]
+
+        def setup(params, errors, path)
+          @counter = Counters.parse(Mechanics.fetch_param(params, :counter), errors, "#{path}.counter")
+        end
+
+        def apply(engine, ctx)
+          n = amount_for(engine, ctx)
+          objects(engine, ctx).each { engine.remove_counters!(engine.object(it), counter, n) }
+        end
+
+        def to_s = "remove #{amount} #{counter} counter(s) → #{to}"
+      end
+
+      # "Remove all +1/+1 counters from it" / "remove all counters from it".
+      class RemoveAllCounters < Effect
+        primitive :effect, :remove_all_counters,
+                  description: "Remove every counter named `counter` (every counter, if no `counter` is given) from " \
+                               "each referenced permanent.",
+                  rules: %w[122.8],
+                  params: { "counter" => "optional counter name", "to" => "selector" },
+                  example: { "remove_all_counters" => { "counter" => "+1/+1", "to" => { "target" => 0 } } }
+
+        attr_reader :counter
+
+        def self.keys = %w[counter to if]
+
+        def setup(params, errors, path)
+          raw = Mechanics.fetch_param(params, :counter)
+          @counter = raw && Counters.parse(raw, errors, "#{path}.counter")
+        end
+
+        def apply(engine, ctx) = objects(engine, ctx).each { engine.remove_all_counters!(engine.object(it), counter) }
+        def to_s = "remove all #{counter || "counters"} → #{to}"
+      end
+
+      # "Choose a counter on target permanent. Put another counter of that kind on it." (CR 122.1, 122.6):
+      # for each referenced permanent with counters, its controller's chosen kind among the kinds already on
+      # it (no choice with only one kind) gets one more counter. Nothing happens to one without counters.
+      class AnotherCounter < ChoiceEffect
+        primitive :effect, :another_counter,
+                  description: "For each referenced permanent, the controller chooses a kind of counter already on it " \
+                               "(asked only when there are several kinds) and puts one more counter of that kind on it.",
+                  rules: %w[122.1 122.6],
+                  params: { "to" => "selector" },
+                  example: { "another_counter" => { "to" => { "target" => 0 } } }
+
+        def self.keys = %w[to if]
+
+        def to_s = "another counter of a kind already there → #{to}"
+
+        def run(engine, ctx, locals)
+          unless locals["ids"]
+            return :done unless condition.nil? || condition.true?(engine, ctx)
+
+            locals["ids"] = objects(engine, ctx)
+            locals["i"] = 0
+          end
+          while locals["i"] < locals["ids"].size
+            obj = engine.state.objects[locals["ids"][locals["i"]]]
+            kinds = obj&.zone == :battlefield ? obj.counters.select { |_, n| n.positive? }.keys.sort : []
+            kind = kinds.first
+            if kinds.size > 1
+              answer = answers(locals)[locals.fetch("k", 0)] or return ask_kind(engine, ctx, obj, kinds)
+              kind = answer["counter"]
+              locals["k"] = locals.fetch("k", 0) + 1
+            end
+            engine.add_counters!(obj, kind, 1, by_player: ctx.controller) if kind
+            locals["i"] += 1
+          end
+          :done
+        end
+
+        private
+
+        def ask_kind(engine, ctx, obj, kinds)
+          engine.ask!("kind" => "effect_choice", "player" => ctx.controller,
+                      "prompt" => "Choose a kind of counter on #{obj.id} to put another of",
+                      "choices" => kinds.map { { "type" => "counter", "counter" => it } })
+          :wait
+        end
+      end
+
+      # "Distribute N +1/+1 counters among one or two target creatures" (CR 601.2d): the division was
+      # announced while casting (the spell ability's `divide`); each target that is still legal gets its
+      # share (CR 608.2b).
+      class DistributeCounters < Effect
+        primitive :effect, :distribute_counters,
+                  description: "Put on each legal target the number of `counter` counters assigned to it as the spell " \
+                               "or ability was cast (its `divide` amount, at least one per target).",
+                  rules: %w[601.2d 608.2b 122.1],
+                  params: { "counter" => "counter name" },
+                  example: { "distribute_counters" => { "counter" => "+1/+1" } }
+
+        attr_reader :counter
+
+        def self.keys = %w[counter if]
+        def self.default_to = "you"
+
+        def setup(params, errors, path)
+          @counter = Counters.parse(Mechanics.fetch_param(params, :counter), errors, "#{path}.counter")
+        end
+
+        def to_s = "distribute #{counter} counters among the targets"
+
+        def apply(engine, ctx)
+          engine.object(ctx.object).memory.fetch("division", {}).each do |ref, n|
+            next unless ctx.targets.flatten.include?(ref) # still a legal target (CR 608.2b)
+
+            engine.add_counters!(engine.object(ref), counter, n, by_player: ctx.controller)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Deal N damage (CR 120).
+      class DealDamage < Effect
+        primitive :effect, :deal_damage,
+                  description: "Deal `amount` damage to each referenced creature, planeswalker or player. Damage to a " \
+                               "player causes life loss; to a planeswalker removes loyalty counters; to a creature " \
+                               "is marked until cleanup. {\"this_way\": n} naming it is the excess damage it dealt " \
+                               "(beyond lethal damage, or a planeswalker's loyalty).",
+                  rules: %w[120.3a 120.3c 120.3e 120.6 120.4a 120.10],
+                  params: { "amount" => "integer", "to" => "selector" },
+                  example: { "deal_damage" => { "amount" => 3, "to" => { "target" => 0 } } }
+
+        # The excess damage it deals (beyond lethal damage to a creature, or a planeswalker's loyalty) is
+        # what {"this_way": n} reads ("if excess damage was dealt this way", CR 120.4a, 120.10).
+        def apply(engine, ctx)
+          n = amount_for(engine, ctx)
+          source = ctx.source || ctx.object
+          refs(engine, ctx).each do |ref|
+            lethal = engine.lethal_damage(source, ref)
+            engine.record_amount!(engine.excess_damage(lethal, engine.deal_damage!(source, ref, n)))
+          end
+        end
+      end
+
+      # "Deals 3 damage divided as you choose among one, two, or three targets" (CR 601.2d): the division was
+      # announced as the spell or ability was put on the stack (its `divide` amount, at least one per target);
+      # each target that is still legal is dealt its share (CR 608.2b).
+      class DistributeDamage < Effect
+        primitive :effect, :distribute_damage,
+                  description: "Deal each legal target the damage assigned to it as the spell or ability was cast or " \
+                               "put on the stack (its `divide` amount, at least one per target). {\"this_way\": n} " \
+                               "naming it is the excess damage dealt.",
+                  rules: %w[601.2d 608.2b 120.3 120.4a],
+                  params: {},
+                  example: { "distribute_damage" => {} }
+
+        def self.keys = %w[if]
+        def self.default_to = "you"
+
+        def to_s = "deal the divided damage to the targets"
+
+        def apply(engine, ctx)
+          source = ctx.source || ctx.object
+          excess = engine.object(ctx.object).memory.fetch("division", {}).sum do |ref, n|
+            next 0 unless ctx.targets.flatten.include?(ref) # still a legal target (CR 608.2b)
+
+            engine.excess_damage(engine.lethal_damage(source, ref), engine.deal_damage!(source, ref, n))
+          end
+          engine.record_amount!(excess)
+        end
+      end
+
+      # "All damage already dealt to it is healed" / "remove all damage from it" (CR 120.6, 514.2).
+      class RemoveDamage < Effect
+        primitive :effect, :remove_damage,
+                  description: "Remove all damage marked on each referenced permanent.",
+                  rules: %w[120.6 514.2],
+                  params: { "to" => "selector" },
+                  example: { "remove_damage" => { "to" => { "target" => 0 } } }
+
+        def self.keys = %w[to if]
+
+        def apply(engine, ctx) = objects(engine, ctx).each { engine.remove_damage!(engine.object(it)) }
+        def to_s = "remove all damage → #{to}"
+      end
+    end
+  end
+end