enjine 0.1.0

data/lib/enjine/mechanics/filters/stack.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Filters
+      # A spell on the stack.
+      class Spell < Filter
+        primitive :filter, :spell, description: "A spell on the stack.", rules: %w[112.1 115.1], example: "spell"
+        def self.zone = :stack
+        def self.match_object?(_engine, object, _controller) = object.kind == "card"
+      end
+
+      # An activated or triggered ability on the stack (CR 113.1b, 115.1): "counter target activated or
+      # triggered ability", "copy target triggered ability you control from a creature source". Mana
+      # abilities never use the stack (CR 605.3b), so they can't be targeted.
+      class StackAbility < Filter
+        KINDS = %w[activated triggered].freeze
+        CONTROLLERS = %w[you opponent].freeze
+
+        primitive :filter, :stack_ability,
+                  description: "An activated or triggered ability on the stack. `kind`: \"activated\" or \"triggered\" " \
+                               "for only one of them; `controller`: you | opponent; `source`: a filter its source " \
+                               "matches (e.g. \"creature\", \"artifact\").",
+                  rules: %w[113.1b 115.1 605.3b 113.7],
+                  params: { "kind" => KINDS.join(" | "), "controller" => CONTROLLERS.join(" | "), "source" => "filter" },
+                  example: { "stack_ability" => { "controller" => "you", "source" => "creature" } }
+
+        def self.zone = :stack
+        def self.match_object?(_engine, object, _controller) = object.ability?
+
+        def self.build(params, errors, path, **)
+          return self if params.empty?
+
+          Mechanics.check_keys(params, %w[kind controller source], errors, path)
+          kind, controller, source = params.values_at("kind", "controller", "source")
+          errors << "#{path}.kind: must be one of #{KINDS.join(", ")}" unless kind.nil? || KINDS.include?(kind)
+          unless controller.nil? || CONTROLLERS.include?(controller)
+            errors << "#{path}.controller: must be one of #{CONTROLLERS.join(", ")}"
+          end
+          source &&= Mechanics.build_entry(:filter, source, errors, "#{path}.source")
+          Narrowed.new(kind, controller, source)
+        end
+
+        # Only activated (loyalty included) or only triggered abilities, of a controller, from a kind of source.
+        class Narrowed
+          def initialize(kind, controller, source)
+            @kind = kind
+            @controller = controller
+            @source = source
+            freeze
+          end
+
+          def primitive_name = "stack_ability"
+
+          def to_s
+            whose = { "you" => " you control", "opponent" => " an opponent controls" }[@controller]
+            "#{@kind || "activated or triggered"} ability#{whose}#{" from a source: #{Triggers.filter_words(@source)}" if @source}"
+          end
+
+          def candidates(engine, controller) = StackAbility.candidates(engine, controller).select { narrow?(engine, it, controller) }
+
+          def candidates_for(engine, controller, _source, **) = candidates(engine, controller)
+
+          def match?(engine, ref, controller) = StackAbility.match?(engine, ref, controller) && narrow?(engine, ref, controller)
+
+          def match_for?(engine, ref, controller, _source, **) = match?(engine, ref, controller)
+
+          def matches_types?(_types) = false
+          def matches_facts?(_facts) = false
+          def live_keys = []
+          def uses_chosen? = false
+
+          private
+
+          def narrow?(engine, ref, controller)
+            obj = engine.object(ref)
+            return false if @kind && (engine.stack_ability(obj).kind == :triggered) != (@kind == "triggered")
+            return false if @controller && (@controller == "you") != (obj.controller == controller)
+
+            @source.nil? || source_ok?(engine, obj)
+          end
+
+          # CR 113.7: the source of an ability is the object that created it; one that has left the
+          # battlefield is matched as it last existed (its card's characteristics).
+          def source_ok?(engine, obj)
+            source = engine.state.objects[obj.source]
+            return @source.match_for?(engine, source.id, obj.controller, nil) if source&.zone == :battlefield
+
+            card = source&.card || obj.card
+            defn = engine.catalog.fetch(card)
+            @source.matches_facts?(Facts.new(chars: defn.printed_characteristics, counters: {}, token: defn.token?))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/follow_up.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    # Effects that happen right after a replacement or prevention effect applies: "prevent that damage and
+    # put that many +1/+1 counters on him" (CR 615.5), "instead exile it and you gain 2 life" (CR 614.1a), and
+    # "exile it instead. When you do, ..." (a reflexive_trigger among them, CR 603.12). A `then` list of
+    # effects that need no choice. They see {"triggering": "amount"} (the damage prevented), "object" (the
+    # damage source, or the card exiled instead) and "player" (that object's controller).
+    #
+    # The FollowUp is one of its card's nested effects, so CardDefinition#ability finds its effects by `ref`;
+    # a replacement names it in the event it modifies ("follow_ups") and the engine runs it once the event
+    # is done (Engine::FollowUps).
+    class FollowUp
+      Effects = Data.define(:effects) # what CardDefinition#ability(ref) returns
+
+      attr_reader :ref, :delayed_ability
+
+      def self.build(params, errors, path)
+        raw = Mechanics.fetch_param(params, :then)
+        return nil if raw.nil?
+
+        effects = Abilities::StackAbility.parse_effects({ "then" => raw }, errors, path, 0, key: :then)
+        errors << "#{path}.then: needs at least one effect" if raw.is_a?(Array) && raw.empty?
+        new("then:#{path}", effects)
+      end
+
+      def initialize(ref, effects)
+        @ref = ref
+        @delayed_ability = Effects.new(effects: effects)
+        freeze
+      end
+
+      def effects = delayed_ability.effects
+      def nested_effects = effects
+      def try_effects = []
+      def to_s = effects.join(", ")
+
+      # The entry a replacement adds to the event's "follow_ups": what runs it later, as plain data.
+      def entry(card, controller, source, facts)
+        { "card" => card, "ref" => ref, "controller" => controller,
+          "source" => source, "facts" => facts.compact }
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/keywords/alternative_costs.rb

@@ -0,0 +1,361 @@
+# frozen_string_literal: true
+
+require_relative "../effects/delayed_triggers"
+
+module Enjine
+  module Mechanics
+    module Abilities
+      # Keyword abilities that are alternative costs (CR 118.9, 601.2b, 601.2f-h): "you may cast this card
+      # [from a zone] by paying [cost] rather than paying its mana cost". Each is offered as its own cast
+      # option, `{type: "cast", object: id, via: "alt:<ability ref>"}`, while the ability functions (the card
+      # is in the right zone, and any other condition holds). `cost` is a mana cost string, or a list of
+      # costs like kicker's (mana and/or chosen costs such as `tap_permanents`). How a spell was cast is
+      # remembered (the `cast_with` / `cast_from` conditions, CR 400.7d). See Engine::AltCasting.
+      class AlternativeCost < Primitive
+        attr_reader :costs, :mana_cost, :ref_path
+
+        # `{"cost": "{2}{R}"}` or `{"cost": [{"mana": "{2}{R}"}, {"tap_permanents": {...}}]}`.
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[cost], errors, path)
+          raw = Mechanics.fetch_param(params, :cost)
+          costs = read_costs(raw, errors, path)
+          new(costs, path, errors)
+        end
+
+        def self.read_costs(raw, errors, path)
+          return [] if raw.nil? && optional_cost?
+
+          if raw.nil?
+            errors << "#{path}.cost: required"
+            return []
+          end
+          return [Costs::ManaPayment.build(raw, errors, "#{path}.cost")] if raw.is_a?(String)
+
+          costs = StackAbility.parse_costs({ "cost" => raw }, errors, path)
+          errors << "#{path}.cost: must be a mana cost string or a non-empty list of costs" if raw.is_a?(Array) && raw.empty?
+          costs.each_with_index do |cost, i|
+            next if cost.mana? || cost.respond_to?(:choices_needed) || cost.respond_to?(:spell_cost?)
+
+            errors << "#{path}.cost[#{i}]: an alternative cost must be mana, life or a chosen cost (tap, sacrifice, ...)"
+          end
+          costs
+        end
+
+        def self.optional_cost? = false
+
+        def initialize(costs, path, _errors)
+          super()
+          @costs = costs.freeze
+          @mana_cost = costs.empty? ? nil : Mana.sum_costs(costs.select(&:mana?).map(&:mana_cost))
+          @ref_path = path
+          freeze
+        end
+
+        def kind = :alternative_cost
+        def keyword = self.class.primitive_name
+        def mana_ability? = false
+        def allowed_types = nil
+        def try_effects = []
+        def choosing_costs = costs.reject(&:mana?)
+
+        # The zone the ability lets the card be cast from (CR 113.6).
+        def zone = :hand
+
+        # Whether the card `obj` (owned by `index`) may be cast this way now, before timing and cost checks.
+        def functions?(_engine, obj, _index) = obj.zone == zone
+
+        # Paid instead of the mana cost? (Mayhem without a cost only allows playing it.)
+        def alternative? = !mana_cost.nil?
+
+        # "If the [keyword] cost was paid, exile this card instead of putting it anywhere else any time it would
+        # leave the stack."
+        def exiles? = false
+
+        # What creature, if any, is returned to its owner's hand as part of the cost: nil, "tapped" (web-slinging)
+        # or "unblocked" (sneak).
+        def returns = nil
+
+        # Cast "any time you could cast an instant" (sneak).
+        def instant_speed? = false
+
+        # "play" also lets a land be played (mayhem without a cost).
+        def play = "cast"
+
+        def cost_text = costs.empty? ? "" : " #{costs.join(", ")}"
+        def to_s = "#{keyword.split("_").map(&:capitalize).join("-")}#{cost_text}"
+
+        # The cast method (Engine::Permissions) this ability gives.
+        def method_for(ref)
+          method = { "via" => "alt:#{ref}", "play" => play, "keyword" => keyword }
+          return method unless alternative?
+
+          alt = { "cost" => mana_cost.to_s, "ref" => ref }
+          alt["exile"] = true if exiles?
+          alt["returns"] = returns if returns
+          alt["harmonize"] = true if is_a?(Harmonize)
+          method["instant"] = true if instant_speed?
+          method.merge("alt" => alt)
+        end
+      end
+
+      # CR 702.34a: flashback, from the graveyard for an instant or sorcery; exiled whenever it would leave the stack.
+      class Flashback < AlternativeCost
+        primitive :ability, :flashback,
+                  description: "Flashback: you may cast this instant or sorcery card from your graveyard by paying " \
+                               "`cost` rather than its mana cost; then it's exiled whenever it would leave the stack. " \
+                               "`cost` is a mana cost string or a list of costs (`[{\"mana\": \"{1}{U}\"}, " \
+                               "{\"tap_permanents\": {\"count\": 3}}]`). Cast option `via: \"alt:<ref>\"`.",
+                  rules: %w[702.34a 118.9 601.2b 601.2f 601.2h],
+                  params: { "cost" => "mana cost string, or a list of costs" },
+                  example: { "flashback" => { "cost" => "{2}{R}" } }
+
+        def zone = :graveyard
+        def exiles? = true
+        def allowed_types = %i[instant sorcery]
+      end
+
+      # CR 702.180a-b: harmonize, from the graveyard, tapping up to one untapped creature you control to reduce
+      # the total cost by its power; exiled whenever it would leave the stack.
+      class Harmonize < AlternativeCost
+        primitive :ability, :harmonize,
+                  description: "Harmonize: you may cast this card from your graveyard by paying `cost` and tapping up " \
+                               "to one untapped creature you control rather than its mana cost; the total cost is " \
+                               "reduced by generic mana equal to that creature's power. Then it's exiled whenever it " \
+                               "would leave the stack. The creature is a `choose_cost` decision (`{type: \"cost\"}` " \
+                               "without an object taps none). Cast option `via: \"alt:<ref>\"`.",
+                  rules: %w[702.180a 702.180b 118.9 601.2b 601.2f 601.2h],
+                  params: { "cost" => "mana cost string, or a list of costs" },
+                  example: { "harmonize" => { "cost" => "{4}{G}" } }
+
+        def zone = :graveyard
+        def exiles? = true
+      end
+
+      # CR 702.187a-c: mayhem, from the graveyard if you discarded the card this turn; without a cost, the card
+      # may be played (a land too) for its usual costs.
+      class Mayhem < AlternativeCost
+        primitive :ability, :mayhem,
+                  description: "Mayhem: as long as you discarded this card this turn, you may cast it from your " \
+                               "graveyard by paying `cost` rather than its mana cost. Without `cost` (`\"mayhem\"`), " \
+                               "you may play it from your graveyard (a land too) if you discarded it this turn. Cast " \
+                               "option `via: \"alt:<ref>\"`.",
+                  rules: %w[702.187a 702.187b 702.187c 118.9 601.2b 601.2f 601.2h 305.1],
+                  params: { "cost" => "mana cost string, or a list of costs (optional)" },
+                  example: { "mayhem" => { "cost" => "{1}{R}" } }
+
+        def self.optional_cost? = true
+
+        def zone = :graveyard
+        def play = alternative? ? "cast" : "play"
+        def functions?(engine, obj, _index) = obj.zone == zone && engine.discarded_this_turn?(obj)
+      end
+
+      # CR 702.185a-c: warp, from the hand. The permanent is exiled at the beginning of the next end step; its
+      # owner may cast it from exile after this turn for as long as it remains exiled.
+      class Warp < AlternativeCost
+        primitive :ability, :warp,
+                  description: "Warp: you may cast this card from your hand by paying `cost` rather than its mana " \
+                               "cost. If you do, the permanent it becomes is exiled at the beginning of the next end " \
+                               "step (a delayed triggered ability), and its owner may cast it from exile after this " \
+                               "turn has ended for as long as it remains exiled (cast option `via: \"warped\"`). " \
+                               "Conditions `{\"cast_with\": \"warp\"}` and `{\"cast_with_this_turn\": \"warp\"}` read it.",
+                  rules: %w[702.185a 702.185b 702.185c 603.7 118.9 601.2b 601.2f 601.2h],
+                  params: { "cost" => "mana cost string, or a list of costs" },
+                  example: { "warp" => { "cost" => "{1}{R}" } }
+
+        attr_reader :delayed
+
+        def initialize(costs, path, errors)
+          @delayed = Effects::WarpDelayed.build({}, errors, path)
+          super
+        end
+
+        def try_effects = [delayed]
+      end
+
+      # CR 702.74a: evoke, from the hand; "When this permanent enters, if its evoke cost was paid, its controller
+      # sacrifices it" is a linked triggered ability.
+      class Evoke < AlternativeCost
+        primitive :ability, :evoke,
+                  description: "Evoke: you may cast this card by paying `cost` rather than its mana cost. When the " \
+                               "permanent enters, if its evoke cost was paid, its controller sacrifices it (a triggered " \
+                               "ability that comes with the keyword). Cast option `via: \"alt:<ref>\"`.",
+                  rules: %w[702.74a 118.9 601.2b 601.2f 601.2h 603.4],
+                  params: { "cost" => "mana cost string, or a list of costs" },
+                  example: { "evoke" => { "cost" => "{R/W}{R/W}" } }
+
+        SACRIFICE = { "triggered" => { "when" => { "enters" => {} }, "if" => { "cast_with" => "evoke" },
+                                       "effects" => [{ "sacrifice" => { "to" => "self" } }] } }.freeze
+
+        attr_reader :linked_abilities
+
+        def initialize(costs, path, errors)
+          @linked_abilities = [Mechanics.build_entry(:ability, SACRIFICE, errors, "#{path}.sacrifice")].compact.freeze
+          super
+        end
+
+        def allowed_types = %i[artifact creature enchantment planeswalker]
+      end
+
+      # CR 702.188a: web-slinging, paying `cost` and returning a tapped creature you control to its owner's hand.
+      class WebSlinging < AlternativeCost
+        primitive :ability, :web_slinging,
+                  description: "Web-slinging: you may cast this spell by paying `cost` and returning a tapped creature " \
+                               "you control to its owner's hand rather than its mana cost. The creature is a " \
+                               "`choose_cost` decision, returned as the spell becomes cast. Cast option " \
+                               "`via: \"alt:<ref>\"`.",
+                  rules: %w[702.188a 118.9 601.2b 601.2f 601.2h],
+                  params: { "cost" => "mana cost string, or a list of costs" },
+                  example: { "web_slinging" => { "cost" => "{2}{G}" } }
+
+        def returns = "tapped"
+      end
+
+      # CR 702.190a-b: sneak, during your declare blockers step at instant speed, paying `cost` and returning an
+      # unblocked attacking creature you control to its owner's hand. A permanent spell enters tapped and
+      # attacking whatever that creature was attacking.
+      class Sneak < AlternativeCost
+        primitive :ability, :sneak,
+                  description: "Sneak: any time you could cast an instant during your declare blockers step, you may " \
+                               "cast this spell by paying `cost` and returning an unblocked attacking creature you " \
+                               "control to its owner's hand rather than its mana cost. A permanent spell cast this way " \
+                               "enters tapped and attacking what that creature was attacking. Cast option " \
+                               "`via: \"alt:<ref>\"`.",
+                  rules: %w[702.190a 702.190b 506.3a 118.9 601.2b 601.2f 601.2h],
+                  params: { "cost" => "mana cost string, or a list of costs" },
+                  example: { "sneak" => { "cost" => "{1}{B}" } }
+
+        def returns = "unblocked"
+        def instant_speed? = true
+
+        def functions?(engine, obj, index)
+          obj.zone == zone && engine.state.active == index && engine.state.step == :declare_blockers
+        end
+      end
+    end
+
+    module Effects
+      # The delayed triggered ability of warp (CR 702.185a): "exile the permanent this spell becomes at the
+      # beginning of the next end step". It is created as the spell becomes cast and watches the spell; the
+      # permanent it became remembers the spell ("warp_spell"). Not a card-data primitive.
+      class WarpDelayed < DelayedTrigger
+        END_STEP = { "step_begins" => { "step" => "end", "whose" => "each" } }.freeze
+
+        def self.keys = []
+
+        def setup(_params, errors, path)
+          @ref = "delayed:#{path}"
+          trigger = Mechanics.build_entry(:trigger, END_STEP, errors, "#{path}.when")
+          exile = WarpExile.build({ "to" => "watched" }, errors, "#{path}.exile")
+          @delayed_ability = Abilities::TriggeredAbility.new(targets: [].freeze, effects: [exile].freeze, trigger: trigger)
+        end
+
+        def to_s = "at the beginning of the next end step, exile the permanent this spell became"
+      end
+
+      # Exiles the permanent a warped spell became; the card in exile is "warped" (CR 702.185b) and its owner
+      # may cast it after this turn has ended (Engine::AltCasting#warped_methods).
+      class WarpExile < Effect
+        def self.keys = %w[to]
+
+        def apply(engine, ctx)
+          spells = refs(engine, ctx)
+          engine.state.battlefield.dup.each do |id|
+            next unless spells.include?(engine.object(id).memory["warp_spell"])
+
+            fresh = engine.move!(id, :exile, reason: "warp")
+            fresh.memory["warped"] = engine.state.turn if fresh&.zone == :exile
+          end
+        end
+
+        def to_s = "exile the permanent this spell became"
+      end
+    end
+
+    class Condition
+      # How a spell was cast (CR 601.2a, 400.7d): `{"cast_with": "flashback"}` (cast using that keyword's
+      # ability: "if its evoke cost was paid", "if this spell's mayhem cost was paid"), `{"cast_from":
+      # "graveyard"}` ("if this spell was cast from a graveyard"; `{"not": {"cast_from": "hand"}}` is "from
+      # anywhere other than your hand"), and `{"cast_with_this_turn": "warp"}` (any player cast a spell with
+      # that keyword's cost this turn, CR 702.185c). The resolving spell, or the permanent it became (and
+      # that permanent's triggered abilities), remembers it.
+      class CastHow
+        KEYS = %w[cast_with cast_from cast_with_this_turn].freeze
+        KEYWORDS = %w[flashback harmonize mayhem warp evoke web_slinging sneak foretell].freeze
+        # Optional additional costs announced as the spell is cast (Engine::CastChoices#announce_kicker!):
+        # "if this spell was cast using teamwork" (CR 702.194b), "if this spell's additional cost was paid" (CR 118.8b),
+        # "if the gift was promised" (CR 702.174k).
+        OPTIONAL_TEXT = { "teamwork" => "it was cast using teamwork", "additional_cost" => "its additional cost was paid",
+                          "gift" => "its gift was promised" }.freeze
+        OPTIONAL = OPTIONAL_TEXT.keys.freeze
+        ZONES = %w[hand graveyard exile library outside].freeze
+
+        def self.build(key, data, errors, path)
+          Mechanics.check_keys(data, [key], errors, path)
+          value = data[key]
+          allowed = { "cast_from" => ZONES, "cast_with" => KEYWORDS + OPTIONAL }.fetch(key, KEYWORDS)
+          errors << "#{path}.#{key}: must be one of #{allowed.join(", ")}" unless allowed.include?(value)
+          new(key, value)
+        end
+
+        def initialize(key, value)
+          @key = key
+          @value = value
+          freeze
+        end
+
+        def true?(engine, ctx)
+          return engine.cast_with_this_turn?(@value) if @key == "cast_with_this_turn"
+
+          holder = engine.state.objects[ctx.object || ctx.source]
+          return holder&.memory&.[]("kicked_with") == @value if OPTIONAL.include?(@value)
+
+          holder&.memory&.[](@key) == @value
+        end
+
+        def to_s
+          case @key
+          when "cast_with" then OPTIONAL.include?(@value) ? OPTIONAL_TEXT.fetch(@value) : "its #{@value.tr("_", "-")} cost was paid"
+          when "cast_from" then "it was cast from #{@value == "hand" ? "a hand" : "a #{@value}"}"
+          else "a spell was cast with #{@value.tr("_", "-")} this turn"
+          end
+        end
+      end
+    end
+
+    # Where a spell is cast from (CR 601.2a), as a filter of the `cast` trigger and of `cost_modifier`:
+    # `from` / `not_from` a zone ("spells you cast from anywhere other than your hand" is
+    # {"not_from": "hand"}). Engine#cast_origin knows the zone while the spell is being cast and after.
+    class CastFrom
+      KEYS = %w[from not_from].freeze
+
+      def self.build(params, errors, path)
+        from, not_from = KEYS.map { Mechanics.fetch_param(params, it) }
+        KEYS.zip([from, not_from]).each do |key, zone|
+          next if zone.nil? || Condition::CastHow::ZONES.include?(zone)
+
+          errors << "#{path}.#{key}: must be one of #{Condition::CastHow::ZONES.join(", ")}"
+        end
+        new(from, not_from)
+      end
+
+      def initialize(from, not_from)
+        @from = from
+        @not_from = not_from
+        freeze
+      end
+
+      def match?(zone) = (@from.nil? || zone == @from) && (@not_from.nil? || zone != @not_from)
+
+      WORDS = { "hand" => "your hand", "graveyard" => "a graveyard", "exile" => "exile", "library" => "a library",
+                "outside" => "outside the game" }.freeze
+
+      def to_s
+        return " from #{WORDS.fetch(@from)}" if @from
+        return " from anywhere other than #{WORDS.fetch(@not_from)}" if @not_from
+
+        ""
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/keywords/beam_me_up.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Abilities
+      # Beam me up [cost] (CR 702.196a): "You may cast this card from your graveyard if the
+      # resulting spell is an instant or sorcery spell by paying [cost] and returning a creature you control
+      # to its owner's hand rather than paying its mana cost" and "If the beam me up cost was paid, exile this
+      # card instead of putting it anywhere else any time it would leave the stack." The creature is chosen
+      # while casting (a `choose_cost` decision) and returned as the spell becomes cast (CR 601.2h).
+      class BeamMeUp < Primitive
+        primitive :ability, :beam_me_up,
+                  description: "You may cast this instant or sorcery card from your graveyard for `cost` plus " \
+                               "returning a creature you control to its owner's hand, instead of its mana cost. " \
+                               "If you do, it's exiled whenever it would leave the stack. Offered as a cast option " \
+                               "with `via: \"beam:<ref>\"`.",
+                  rules: %w[702.196a 702.196b 118.9 601.2b 601.2f 601.2h],
+                  params: { "cost" => "mana cost string, e.g. \"{3}{W}\"" },
+                  example: { "beam_me_up" => { "cost" => "{3}{W}" } }
+
+        attr_reader :cost
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[cost], errors, path)
+          new(Mana.parse_cost(Mechanics.fetch_param(params, :cost), errors, "#{path}.cost") || Mana::Cost.new(generic: 0, colored: {}))
+        end
+
+        def initialize(cost)
+          super()
+          @cost = cost
+          freeze
+        end
+
+        def kind = :beam_me_up
+        def mana_ability? = false
+        def allowed_types = %i[instant sorcery]
+        def try_effects = []
+        def to_s = "Beam me up #{cost}"
+      end
+
+      # A static ability of a permanent giving beam me up (CR 702.196a), during its controller's main phase,
+      # to the instant and sorcery cards with a mana cost in their graveyard, each card's mana cost being its
+      # beam me up cost. The permanent itself can't be returned to cast a spell this way (CR 702.196b).
+      class GrantsBeamMeUp < Primitive
+        primitive :ability, :grants_beam_me_up,
+                  description: "While this permanent is on the battlefield, during your main phase each instant and " \
+                               "sorcery card in your graveyard has beam me up with its mana cost as the beam me up " \
+                               "cost; this permanent can't be the creature returned to cast a spell this way. " \
+                               "Offered as a cast option with `via: \"beam_granted:<permanent>:<ref>\"`.",
+                  rules: %w[702.196a 702.196b 604.1 611.3a],
+                  example: "grants_beam_me_up"
+
+        INSTANCE = new.freeze
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, [], errors, path)
+          INSTANCE
+        end
+
+        def kind = :grants_beam_me_up
+        def mana_ability? = false
+        def allowed_types = nil
+        def try_effects = []
+        def to_s = "During your main phase, each card in your graveyard has beam me up (its mana cost)"
+      end
+    end
+
+    module Keywords
+      # CR 702.196b: "If a creature can't be beamed up, its controller can't return it to its owner's hand to
+      # pay the portion of a beam me up cost that requires them to return a creature." A flag like a keyword.
+      class CantBeBeamedUp < Primitive
+        primitive :keyword, :cant_be_beamed_up,
+                  description: "This creature can't be returned to its owner's hand to pay a beam me up cost.",
+                  rules: %w[702.196b], example: { "keywords" => ["cant_be_beamed_up"] }
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/keywords/changeling.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Keywords
+      # Changeling (CR 702.73a): a characteristic-defining ability, "this object is
+      # every creature type". It works in every zone (CR 604.3, 113.6a), so it is applied with the object's
+      # copiable values (Engine::Characteristics#copy_base): the object's subtypes then include every
+      # creature type, and subtype filters, "creature types among" counts and type-changing effects
+      # (layer 4) see them like printed ones.
+      class Changeling < Primitive
+        primitive :keyword, :changeling,
+                  description: "This object is every creature type (a characteristic-defining ability that works " \
+                               "in all zones).",
+                  rules: %w[702.73a 604.3 205.3m 113.6a], example: { "keywords" => ["changeling"] }
+
+        # CR 205.3m: every creature type, written as card data subtypes (lowercase, "-" and
+        # spaces become "_", apostrophes dropped).
+        CREATURE_TYPES = <<~TYPES.split.map(&:to_sym).freeze
+          time_lord advisor aenar aetherborn alien ally andorian android angel antelope ape archer archon armadillo
+          army artificer assassin assembly_worker astartes atog aurochs avatar azra badger bajoran balloon barbarian
+          bard basilisk bat bear beast beaver beeble beholder berserker betazoid bird bison blinkmoth boar bolian
+          borg brikar bringer brushwagg caitian camarid camel capybara cardassian caribou carrier cat centaur child
+          chimera citizen cleric clown cockatrice construct coward coyote crab crocodile ctan custodes cyberman
+          cyclops dalek dauthi demigod demon denobulan deserter detective devil dinosaur djinn doctor dog dragon
+          drake dreadnought drix drone druid dryad dwarf echidna edosian efreet egg el_aurian elder eldrazi
+          elemental elephant elf elk employee eternal excalbian eye faerie ferengi ferret fish flagbearer fox
+          fractal frog fungus gamer gamma gargoyle germ giant giraffe gith glimmer gnoll gnome goat goblin god golem
+          gorgon gorn graveborn gremlin griffin guest hag halfling hamster harpy hedgehog hellion hero hippo
+          hippogriff hirogen homarid homunculus horror horse human hydra hyena illusion illyrian imp incarnation
+          inhuman inkling inquisitor insect jackal jellyfish jemhadar juggernaut kangaroo kavu kelpien kirin kithkin
+          klingon knight kobold kor kraken kree kwejian llama lamia lammasu lanthanite leech lemur leviathan
+          lhurgoyf licid lizard lobster manticore masticore medusan melkotian mercenary merfolk metathran minion
+          minotaur mite mole monger mongoose monk monkey moogle moonfolk mount mouse mutant myr mystic nakuhl
+          nautilus necron nephilim nightmare nightstalker ninja noble noggle nomad nymph ocampa octopus officer ogre
+          ooze orb orc orgg orion otter ouphe ox oyster pangolin peasant pegasus pentavite performer pest
+          phelddagrif phoenix phyrexian pilot pincher pirate plant platypus porcupine possum praetor primarch prism
+          processor q qu rabbit raccoon ranger rat rebel reflection rhino rigger robot rogue romulan sable
+          salamander samurai sand saproling satyr scarecrow scientist scion scorpion scout sculpture seal serf
+          serpent servo shade shaman shapeshifter shark sheep shiar siren skeleton skrull skunk slith sliver sloth
+          slug snail snake soldier soltari sorcerer spawn specter spellshaper sphinx spider spike spirit splinter
+          sponge spy squid squirrel starfish surrakar survivor symbiote synth talaxian talosian tamarian tellarite
+          tentacle tetravite thalakos tholian thopter thrull tiefling tosk toy treefolk tribble trill trilobite
+          triskelavite troll turtle tyranid unicorn utrom vampire varmint vau_nakat vedalken villain volver vorta
+          vulcan wall walrus warlock warrior weasel weird werewolf whale wizard wolf wolverine wombat worm wraith
+          wurm xindi yeti zombie zubera
+        TYPES
+
+        # The characteristics with every creature type added, if the object has changeling.
+        def self.apply(chars)
+          return chars unless chars.keywords.include?(:changeling)
+
+          chars.with(subtypes: (chars.subtypes | CREATURE_TYPES).freeze)
+        end
+      end
+    end
+  end
+end