enjine 0.1.0

data/lib/enjine/engine/combat.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+module Enjine
+  class Engine
+    # Combat (CR 506-511). state.attackers maps attacker id => {"target", "blocked"};
+    # state.blockers maps blocker id => attacker id.
+    module Combat
+      def defending_player = state.opponent(state.active)
+
+      # ---- declare attackers (CR 508) ------------------------------------------
+
+      def begin_declare_attackers!
+        return turn_based_actions_done! if eligible_attackers.empty?
+
+        ask!("kind" => "declare_attackers", "player" => state.active)
+      end
+
+      # CR 508.1a: untapped creatures you've controlled continuously since your turn began (or with haste).
+      # CR 508.1c: restrictions (defender, "can't attack", a player who can't attack) are obeyed.
+      def eligible_attackers
+        return [] if player_rule?(state.active, "cant_attack")
+
+        only = combat_attack_filter # "only land creatures can attack during that combat phase" (TurnStructure)
+        state.battlefield.select do |id|
+          obj = object(id)
+          current = chars(obj)
+          obj.controller == state.active && !obj.tapped && current.creature? &&
+            (!current.keyword?(:defender) || current.keyword?(:attacks_despite_defender)) &&
+            !current.keyword?(:cant_attack) && !attackers.key?(id) && !summoning_sick_for_tap?(obj) &&
+            (only.nil? || only.match?(self, id, state.active))
+        end
+      end
+
+      # CR 508.1d: creatures that attack each combat if able and could still be declared. The
+      # declaration may end only once every such requirement is obeyed (no attack has a cost yet).
+      def unmet_attack_requirements = attack_candidates.select { chars(it).keyword?(:attacks_each_combat) }
+
+      # CR 506.3, 508.1b: the defending player or a planeswalker they control.
+      def attack_targets
+        defender = defending_player
+        [Mechanics::Filters.player_ref(self, defender)] +
+          state.battlefield.select { |id| object(id).controller == defender && chars(id).planeswalker? }
+      end
+
+      # Creatures that may be declared next. CR 506.5, 508.1c: one that can't attack alone is offered
+      # only while another creature attacks or could still be declared.
+      def attack_candidates
+        eligible = eligible_attackers
+        eligible.select { |id| !attacks_alone_restricted?(id) || !attackers.empty? || eligible.size > 1 }
+      end
+
+      def attacks_alone_restricted?(id) = chars(id).keyword?(:cant_attack_alone)
+
+      # CR 508.1c: the declaration is illegal while a creature that can't attack alone attacks alone.
+      def attack_declaration_legal? = !(attackers.size == 1 && attacks_alone_restricted?(attackers.keys.first))
+
+      def declare_attacker!(id, target)
+        attackers[id] = { "target" => target, "blocked" => false }
+        state.attacks_declared += 1
+        emit Events::AttackerDeclared.new(object: id, target: target)
+        eligible_attackers.empty? && attack_declaration_legal? ? finish_attackers! : nil
+      end
+
+      # Undo one attack while the declaration isn't legal yet (CR 508.1c). The declaration it was part of
+      # never happened, so "whenever this attacks" abilities it triggered go too.
+      def withdraw_attacker!(id)
+        attackers.delete(id)
+        state.attacks_declared -= 1
+        attack_withdrawn!(id) # Engine::TurnHistory
+        state.pending_triggers.reject! { it["event"]["type"] == "attacker_declared" && it["event"]["object"] == id }
+      end
+
+      # CR 508.4: a creature put onto the battlefield attacking attacks the defending player. (Choosing one
+      # of their planeswalkers instead isn't offered yet.) It was never declared, so it never "attacked".
+      # Only called while its controller controls an attacking creature (see Abilities::EntersAttacking).
+      def enter_attacking!(obj, target = nil)
+        target = Mechanics::Filters.player_ref(self, state.opponent(obj.controller)) unless target.is_a?(String) # CR 506.3a
+        attackers[obj.id] = { "target" => target, "blocked" => false }
+      end
+
+      # CR 508.1f: attacking creatures become tapped. CR 508.3d: "whenever you attack" triggers
+      # once the declaration is complete, if one or more creatures attack.
+      def finish_attackers!
+        attackers.each_key { |id| tap!(object(id)) unless chars(id).keyword?(:vigilance) } # CR 702.20b
+        emit Events::AttacksDeclared.new(player: name(state.active), attackers: attackers.keys) unless attackers.empty?
+        turn_based_actions_done!
+      end
+
+      # ---- declare blockers (CR 509) -----------------------------------------------
+
+      def begin_declare_blockers!
+        return turn_based_actions_done! if block_options.empty? || attackers.empty?
+
+        ask!("kind" => "declare_blockers", "player" => defending_player)
+      end
+
+      # CR 509.1a; CR 509.1b: a creature that can't block is never offered.
+      def eligible_blockers = able_blockers.reject { state.blockers.key?(it) }
+
+      # The defending player's creatures that could block, whether they block already or not.
+      def able_blockers
+        state.battlefield.select do |id|
+          obj = object(id)
+          obj.controller == defending_player && !obj.tapped && chars(obj).creature? &&
+            !chars(obj).keyword?(:cant_block) && !chars(obj).keyword?(:decayed) # CR 702.147a
+        end
+      end
+
+      def declare_blocker!(id, attacker)
+        state.blockers[id] = attacker
+        attackers[attacker]["blocked"] = true # CR 509.1h: stays blocked even if the blocker leaves
+        emit Events::BlockerDeclared.new(object: id, attacker: attacker)
+        finish_blockers! if block_options.empty? && blocks_legal?
+      end
+
+      # The declaration is final: each blocked attacker "becomes blocked" once (CR 509.1h, 509.3c, 603.2e).
+      def finish_blockers!
+        attackers.each do |id, info|
+          emit Events::BecameBlocked.new(object: id, blockers: blockers_of(id)) if info["blocked"]
+        end
+        turn_based_actions_done!
+      end
+
+      # CR 509.1b restrictions: "can't be blocked", "can't be blocked by [quality] creatures", flying
+      # (702.9b) / reach (702.17b), protection from the blocker's quality (702.16f).
+      def can_block?(blocker, attacker)
+        return false if chars(attacker).keyword?(:cant_be_blocked)
+        return false if protected_from?(object(attacker), object(blocker))
+        return false if chars(attacker).abilities.any? { it.ability.kind == :cant_be_blocked_by && it.ability.forbids?(self, blocker) }
+        return false if chars(blocker).abilities.any? { it.ability.kind == :can_block_only && !it.ability.allows?(self, blocker, attacker) }
+        return true unless chars(attacker).keyword?(:flying)
+
+        chars(blocker).keyword?(:flying) || chars(blocker).keyword?(:reach)
+      end
+
+      def block_options
+        eligible_blockers.flat_map do |id|
+          attackers.keys.filter_map { |attacker| [id, attacker] if can_block?(id, attacker) }
+        end
+      end
+
+      # CR 702.111b: an attacker with menace can't be blocked by just one creature.
+      # CR 509.1c: an attacker that must be blocked if able is blocked whenever some creature could block it.
+      def blocks_legal? = menace_violations.empty? && unmet_block_requirements.empty?
+
+      # Attackers that must be blocked if able, unblocked while creatures could block them: blocking another
+      # attacker instead obeys fewer requirements (CR 509.1c). With menace it takes two (CR 509.1b).
+      def unmet_block_requirements
+        attackers.keys.select do |id|
+          next false unless chars(id).keyword?(:must_be_blocked) && blockers_of(id).empty?
+
+          able_blockers.count { could_obey?(it, id) } >= (chars(id).keyword?(:menace) ? 2 : 1)
+        end
+      end
+
+      # Whether `blocker` blocking `attacker` would obey more requirements: it can block it and blocks nothing,
+      # or blocks an attacker without such a requirement (moving it from one that must be blocked gains nothing).
+      def could_obey?(blocker, attacker)
+        return false unless can_block?(blocker, attacker)
+
+        blocking = state.blockers[blocker]
+        blocking.nil? || !chars(blocking).keyword?(:must_be_blocked)
+      end
+
+      # Blocks to undo so a creature can block an attacker that must be blocked.
+      def requirement_unblocks
+        unmet_block_requirements.flat_map { |id| state.blockers.keys.select { could_obey?(it, id) } }.uniq
+      end
+
+      def menace_violations
+        attackers.keys.select { |id| chars(id).keyword?(:menace) && blockers_of(id).size == 1 }
+      end
+
+      # Undo one block (offered while the declaration isn't legal yet).
+      def remove_blocker!(id)
+        attacker = state.blockers.delete(id)
+        attackers[attacker]["blocked"] = blockers_of(attacker).any? # the declaration isn't final yet
+      end
+
+      def blockers_of(attacker) = state.blockers.select { |_, a| a == attacker }.keys
+
+      # ---- combat damage (CR 510) -----------------------------------------------
+
+      # CR 510.1c: an attacker blocked by several creatures divides its damage among them
+      # as its controller chooses — asked one point at a time.
+      # CR 510.4: if any attacking or blocking creature has first or double strike, there are
+      # two combat damage steps: first strikers deal damage in the first, the rest in the second.
+      def begin_combat_damage!
+        state.combat_damage_pass ||= combatants.any? { first_striker?(it) } ? "first" : "regular"
+        queue = attackers.keys.select { |id| needs_assignment?(id) }
+        state.frames << { "type" => "combat_damage", "queue" => queue, "assigned" => {} }
+      end
+
+      def combatants = attackers.keys + state.blockers.keys
+
+      def first_striker?(id) = chars(id).keyword?(:first_strike) || chars(id).keyword?(:double_strike)
+
+      # Whether this creature deals combat damage in the current pass (CR 702.4b, 702.7b).
+      def deals_damage_now?(id)
+        case state.combat_damage_pass
+        when "first" then first_striker?(id)
+        when "regular_after_first" then !chars(id).keyword?(:first_strike) || chars(id).keyword?(:double_strike)
+        else true
+        end
+      end
+
+      # The second combat damage step follows a first-strike step (CR 510.4).
+      def second_combat_damage_step?
+        return false unless state.step == :combat_damage && state.combat_damage_pass == "first"
+
+        state.combat_damage_pass = "regular_after_first"
+        true
+      end
+
+      def trample?(id) = chars(id).keyword?(:trample)
+
+      # CR 510.1a: the combat damage a creature assigns: its power, or its toughness when an effect says so
+      # and its toughness is greater (assigns_damage_by_toughness).
+      def combat_damage_amount(id)
+        obj = object(id)
+        amount = power(obj)
+        chars(id).keyword?(:assigns_damage_by_toughness) ? [amount, toughness(obj)].max : amount
+      end
+
+      # CR 510.1c-d / 702.19b: several blockers, or trample, means the attacking player divides damage.
+      def needs_assignment?(id)
+        return false unless attackers[id]["blocked"] && deals_damage_now?(id) && combat_damage_amount(id).positive?
+
+        count = blockers_of(id).size
+        count > 1 || (count == 1 && trample?(id))
+      end
+
+      def combat_damage_frame = state.frames.last
+
+      # Steps the combat_damage frame: ask for the next point of damage to divide, or deal it all.
+      def step_combat_damage!(frame)
+        while (attacker = frame["queue"].first)
+          assigned = frame["assigned"][attacker] ||= {}
+          remaining = combat_damage_amount(attacker) - assigned.values.sum
+          if remaining.positive?
+            ask!("kind" => "assign_damage", "player" => state.active, "attacker" => attacker, "remaining" => remaining)
+            return :wait
+          end
+          frame["queue"].shift
+        end
+        deal_combat_damage!(frame["assigned"])
+        :done
+      end
+
+      # Where the next point of an attacker's damage may go: any blocker; with trample, also
+      # the player or planeswalker it attacks once every blocker has lethal damage assigned.
+      def assignment_targets(attacker)
+        blockers = blockers_of(attacker)
+        assigned = combat_damage_frame["assigned"].fetch(attacker, {})
+        return blockers unless trample?(attacker) && blockers.all? { lethal_assigned?(attacker, it, assigned) }
+
+        blockers + [attackers[attacker]["target"]]
+      end
+
+      # CR 702.19b: lethal damage counts damage already marked; with deathtouch, 1 is lethal (702.2c).
+      def lethal_assigned?(attacker, blocker, assigned)
+        assigned.fetch(blocker, 0) >= [lethal_damage(attacker, blocker), 1].max
+      end
+
+      def assign_damage!(attacker, target)
+        assigned = combat_damage_frame["assigned"][attacker]
+        assigned[target] = assigned.fetch(target, 0) + 1
+        emit Events::DamageAssigned.new(attacker: attacker, blocker: target)
+        ask!(nil)
+      end
+
+      # CR 510.2: all combat damage in a step is dealt simultaneously.
+      def deal_combat_damage!(assigned)
+        hits = []
+        attackers.each do |id, info|
+          next unless deals_damage_now?(id)
+
+          amount = combat_damage_amount(id)
+          blockers = blockers_of(id)
+          if !info["blocked"] then hits << [id, info["target"], amount]
+          elsif blockers.empty? then hits << [id, info["target"], amount] if trample?(id) # CR 702.19e
+          elsif assigned.key?(id) then assigned[id].each { |target, n| hits << [id, target, n] }
+          else hits << [id, blockers.first, amount]
+          end
+        end
+        state.blockers.each do |blocker, attacker|
+          hits << [blocker, attacker, combat_damage_amount(blocker)] if deals_damage_now?(blocker)
+        end
+        simultaneous_damage do # CR 510.2
+          dealt = Hash.new(0)
+          lifelinked = hits.map(&:first).uniq.select { damage_source_keyword?(it, :lifelink) }
+          hits.each { |source, target, amount| dealt[source] += deal_damage!(source, target, amount, combat: true, lifelink: false) }
+          lifelinked.each { lifelink!(it, dealt[it]) if dealt[it].positive? } # CR 120.3f, 119.9: one gain per source
+        end
+        turn_based_actions_done!
+      end
+
+      # CR 506.4: a permanent that leaves the battlefield is removed from combat.
+      def leave_combat!(id)
+        attackers.delete(id)
+        state.blockers.delete(id)
+        state.blockers.reject! { |_, attacker| attacker == id }
+      end
+
+      # CR 511.3: creatures stop being attacking/blocking at the end of combat.
+      def end_combat!
+        state.attacks_declared = 0
+        state.combat_damage_pass = nil
+        attackers.clear
+        state.blockers.clear
+      end
+    end
+    include Combat
+  end
+end

data/lib/enjine/engine/copies.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Enjine
+  class Engine
+    # Copying objects (CR 707).
+    #
+    # A copy takes the copiable values of the object it copies (CR 707.2): the values printed on its card,
+    # as modified by other copy effects and their exceptions (CR 707.9b). Every copiable value comes from a
+    # card definition plus a few exceptions, so a copy is kept as plain data on the GameObject:
+    #
+    #   obj.card                      the card whose printed values it has: the copied card while a copy
+    #                                 effect applies (so its abilities, triggers and stack objects all
+    #                                 resolve against that card's data)
+    #   memory["own_card"]            the card the object really is, while a copy effect changed obj.card
+    #   memory["copy_effects"]        copy effects on a permanent, in timestamp order (CR 613.7): each
+    #                                 {"card", "except", "duration" ("permanent" | "end_of_turn"), "timestamp"}
+    #   memory["copy_except"]         the exceptions of an object created as a copy (a token copy, CR 707.9)
+    #   memory["token"]               true for a token that is a copy of a card (CR 111.1, 608.3f)
+    #   memory["copy"]                "spell" for a copy of a spell (CR 707.10), "card" for a copy of a card
+    #                                 (CR 707.12); they cease to exist outside the stack (and battlefield)
+    #
+    # Exceptions (CR 707.9a-b) are {"legendary": false, "keywords": [...], "types": [...], "subtypes": [...],
+    # "supertypes": [...], "name": ..., "power": n, "toughness": n, "colors": [...]}; they are part of the
+    # copy's copiable values, so copying a copy keeps them (CR 707.2).
+    module Copies
+      # ---- reading -------------------------------------------------------------------------------
+
+      def own_card(obj) = obj.memory["own_card"] || obj.card
+
+      # A token (CR 111.1): created as one, or a copy of a permanent spell that resolved (CR 608.3f).
+      def token?(obj) = obj.memory["token"] == true || catalog.fetch(own_card(obj)).token?
+
+      # The exceptions of the copy effect that applies (nil if none).
+      def copy_exceptions(obj)
+        effects = obj.memory["copy_effects"]
+        effects && !effects.empty? ? effects.last["except"] : obj.memory["copy_except"]
+      end
+
+      # What a copy of `obj` gets: [card id, exceptions] (CR 707.2, 707.3).
+      def copiable_values(obj) = [obj.card, copy_exceptions(obj) || {}]
+
+      # 707.9b: exceptions of a later copy effect apply on top of those it copied.
+      def self.merge_except(old, new)
+        old ||= {}
+        merged = old.merge(new.except("keywords", "types", "subtypes", "supertypes"))
+        %w[keywords types subtypes supertypes].each do |key|
+          list = Array(old[key]) | Array(new[key])
+          merged[key] = list unless list.empty?
+        end
+        merged
+      end
+
+      # The characteristics with a copy effect's exceptions applied (CR 707.9a-b).
+      def self.apply_exceptions(chars, except)
+        attrs = {}
+        attrs[:name] = except["name"] if except["name"]
+        attrs[:supertypes] = chars.supertypes | sym(except["supertypes"])
+        attrs[:supertypes] -= [:legendary] if except["legendary"] == false
+        attrs[:types] = chars.types | sym(except["types"])
+        attrs[:subtypes] = chars.subtypes | sym(except["subtypes"])
+        attrs[:keywords] = chars.keywords | sym(except["keywords"])
+        attrs[:colors] = sym(except["colors"]) if except["colors"]
+        attrs[:power] = except["power"] if except.key?("power")
+        attrs[:toughness] = except["toughness"] if except.key?("toughness")
+        chars.with(**attrs.transform_values { it.is_a?(Array) ? it.freeze : it })
+      end
+
+      def self.sym(list) = Array(list).map(&:to_sym)
+
+      # ---- making copies ---------------------------------------------------------------------------
+
+      # CR 707.8, 111.1: a token that's a copy of [card, except], created under `controller`'s control.
+      def create_token_copy!(values, controller, tapped: false)
+        card, except = values
+        memory = { "token" => true }
+        memory["copy_except"] = except unless except.empty?
+        create_token!(catalog.fetch(card), controller, tapped: tapped, memory: memory)
+      end
+
+      # CR 707.4, 613.2a: `obj` becomes a copy of [card, except]; no enter or leave triggers. A
+      # "permanent" copy effect lasts as long as the object stays on the battlefield.
+      def become_copy!(obj, values, duration: "permanent")
+        card, except = values
+        obj.memory["own_card"] ||= obj.card
+        (obj.memory["copy_effects"] ||= []) << { "card" => card, "except" => except, "duration" => duration,
+                                                 "timestamp" => next_timestamp! }
+        obj.card = card
+        emit Events::EffectStarted.new(kind: "copy", affected: [obj.id], details: { "card" => card })
+      end
+
+      # CR 707.5: a permanent entering as a copy ({"card", "except"}) is one as it enters.
+      def enter_as_copy!(fresh, copy)
+        fresh.memory["own_card"] = fresh.card
+        fresh.memory["copy_effects"] = [copy.merge("duration" => "permanent", "timestamp" => next_timestamp!)]
+        fresh.card = copy["card"]
+      end
+
+      # CR 707.12: a copy of a card, created in the zone the card is in (owned by `controller`).
+      def create_card_copy!(values, controller, zone)
+        card, except = values
+        obj = create_object(card, controller, zone)
+        obj.memory["copy"] = "card"
+        obj.memory["copy_except"] = except unless except.empty?
+        state.zone_list(zone, controller).unshift(obj.id)
+        record_result!(obj.id)
+        emit Events::ZoneChanged.new(card: card, old_id: nil, new_id: obj.id, owner: name(controller),
+                                     from: "none", to: zone.to_s, reason: "copy")
+        obj
+      end
+
+      # CR 707.10: a copy of a spell or ability on the stack, with the same modes, X, kicker and other
+      # choices, put on top of the stack by `controller` (who owns and controls it). A spell copy isn't
+      # cast, an ability copy isn't activated; an ability copy has the same source (CR 707.10b) and keeps
+      # what the ability knew (its trigger event, the objects paid for its costs).
+      def copy_spell!(spell, controller, targets, except: {})
+        card, copied = spell.ability? ? [spell.card, {}] : copiable_values(spell)
+        except = except.empty? ? copied : Copies.merge_except(copied, except) # CR 707.9a
+        copy = create_object(card, controller, :stack)
+        if spell.ability?
+          copy.kind = "ability"
+          copy.source = spell.source
+          copy.ability = spell.ability
+          copy.memory = Snapshot.deep_copy(spell.memory.except("trigger_id")) # the copy wasn't triggered
+        else
+          copy.memory = Marshal.load(Marshal.dump(spell.memory.slice("kicked", "kicked_with", "gift", "division"))).merge("copy" => "spell")
+        end
+        copy.memory["copy_except"] = except unless except.empty?
+        copy.targets = targets
+        copy.modes = spell.modes&.dup
+        copy.x = spell.x
+        copy.mana_spent = nil # CR 707.10: mana isn't copied; no mana was spent to cast a copy
+        copy.paid = spell.paid&.map(&:dup)
+        state.stack.unshift(copy.id)
+        record_result!(copy.id)
+        emit Events::SpellCopied.new(player: name(controller), object: copy.id, card: card, original: spell.id,
+                                     targets: targets)
+        copy
+      end
+
+      # ---- zone changes and state-based actions ------------------------------------------------------
+
+      # CR 400.7: the new object is the card itself again; a token or copy stays one. A copy of a permanent
+      # spell becomes a token as it enters (CR 608.3f, 707.10f).
+      def carry_copy_status!(fresh, old, to)
+        fresh.memory["token"] = true if old.memory["token"]
+        fresh.memory["copy_except"] = old.memory["copy_except"] if old.memory["copy_except"]
+        kind = old.memory["copy"] or return
+        return fresh.memory["token"] = true if kind == "spell" && to == :battlefield
+
+        fresh.memory["copy"] = kind
+      end
+
+      # CR 704.5d, 111.7, 707.10a: tokens outside the battlefield, spell copies outside the stack and card
+      # copies outside the stack and battlefield cease to exist (state-based actions).
+      # Zones a token or card copy can be in (a phased-out permanent is still on the battlefield, CR 702.26d).
+      STAYING = %i[battlefield stack phased_out].freeze
+
+      def ceases_to_exist?(obj)
+        return false if obj.ability?
+
+        case obj.memory["copy"]
+        when "spell" then obj.zone != :stack
+        when "card" then !STAYING.include?(obj.zone) && !prepared_copy?(obj) # CR 723.3c (Engine::Faces)
+        else !STAYING.include?(obj.zone) && token?(obj)
+        end
+      end
+
+      # CR 514.2: "until end of turn" copy effects end; the permanent has the copiable values of the
+      # newest copy effect left, or its own.
+      def end_copy_effects!
+        state.battlefield.each do |id|
+          obj = object(id)
+          effects = obj.memory["copy_effects"] or next
+          next unless effects.any? { it["duration"] == "end_of_turn" }
+
+          effects.reject! { it["duration"] == "end_of_turn" }
+          obj.card = effects.last&.fetch("card") || obj.memory["own_card"]
+          obj.memory.delete("copy_effects") if effects.empty?
+          obj.memory.delete("own_card") if effects.empty?
+          emit Events::EffectsEnded.new(count: 1)
+        end
+      end
+
+      # ---- abilities granted to a card (CR 113.6b, 611.3) ----------------------------------------
+
+      # Abilities an object gained from a resolved effect (state.effects "card_ability", lasting while it
+      # stays in its zone or until end of turn), e.g. an exiled card: "granted:<granting card>:<ref>".
+      def card_granted_abilities(obj)
+        state.effects.filter_map do |effect|
+          next unless effect["kind"] == "card_ability" && effect["affected"].include?(obj.id)
+
+          ability = catalog.fetch(effect["card"]).ability(effect["ability"]) or next
+          AbilityInstance.new(ref: "granted:#{effect["card"]}:#{effect["ability"]}", ability: ability)
+        end
+      end
+
+      # Starts a "card_ability" effect; ones whose cards no longer exist are dropped.
+      def grant_card_ability!(ctx, affected, card, ref, duration)
+        state.effects.reject! { it["kind"] == "card_ability" && it["affected"].none? { state.objects.key?(it) } }
+        duration = "while_in_zone" if duration == "permanent" # a new object is a different one (CR 400.7)
+        state.effects << { "kind" => "card_ability", "timestamp" => next_timestamp!, "controller" => ctx.controller,
+                           "affected" => affected, "duration" => duration, "card" => card, "ability" => ref }
+        emit Events::EffectStarted.new(kind: "card_ability", affected: affected, details: { "card" => card })
+      end
+    end
+    include Copies
+  end
+end