enjine 0.1.0

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Creates a delayed triggered ability (CR 603.7): "at the beginning of the next end step,
+      # return it". It is defined here, in the card data, and addressed as "delayed:<path>".
+      class DelayedTrigger < Effect
+        primitive :effect, :delayed_trigger,
+                  description: "Creates a delayed triggered ability with the controller and source of the resolving " \
+                               "spell or ability. It triggers only once, the next time `when` happens (e.g. " \
+                               "{\"step_begins\": {\"step\": \"end\", \"whose\": \"each\"}} for the next end step). Its " \
+                               "`effects` may use {\"result\": n} for what earlier effects of the creating list moved or " \
+                               "created; those objects are affected only if they are still where they were put.",
+                  rules: %w[603.7a 603.7b 603.7c 603.7d 603.7e],
+                  params: { "when" => "a trigger condition", "effects" => "list of effects",
+                            "watch" => "selector resolved now (e.g. {\"target\": 0}): the objects its trigger subject " \
+                                       "\"watched\" and its effects' selector \"watched\" mean (\"when that creature dies\")",
+                            "this_turn" => "true: it lasts until the end of this turn and triggers each time " \
+                                           "(\"whenever ... this turn\", CR 603.7b); \"once\": only the next time " \
+                                           "this turn (\"at the beginning of the next combat this turn\")" },
+                  example: { "delayed_trigger" => { "when" => { "step_begins" => { "step" => "end", "whose" => "each" } },
+                                                    "effects" => [{ "sacrifice" => { "to" => { "result" => 0 } } }] } }
+
+        attr_reader :ref, :delayed_ability
+
+        def self.keys = %w[when effects watch this_turn]
+        def self.default_to = "you"
+
+        def setup(params, errors, path)
+          @ref = "delayed:#{path}"
+          raw = Mechanics.fetch_param(params, :when)
+          trigger = raw.nil? ? ((errors << "#{path}.when: required") && nil) : Mechanics.build_entry(:trigger, raw, errors, "#{path}.when")
+          effects = Abilities::StackAbility.parse_effects(params, errors, path, 0, results_count: @results_count)
+          errors << "#{path}.effects: needs at least one effect" if effects.empty?
+          @delayed_ability = Abilities::TriggeredAbility.new(targets: [].freeze, effects: effects, trigger: trigger)
+          raw_watch = Mechanics.fetch_param(params, :watch)
+          @watch = raw_watch && Selector.build(raw_watch, errors, "#{path}.watch", targets_count: @targets_count,
+                                                                                   results_count: @results_count)
+          @this_turn = Mechanics.fetch_param(params, :this_turn)
+          errors << "#{path}.this_turn: must be true, false or \"once\"" unless [nil, true, false, "once"].include?(@this_turn)
+        end
+
+        def nested_effects = delayed_ability.effects
+        def to_s = "delayed#{" this turn" if @this_turn}: #{delayed_ability}#{" (watching #{@watch})" if @watch}"
+
+        # CR 603.7d-e: controlled by the resolving object's controller, from the same source. It
+        # remembers the results it may name and the objects it watches (CR 603.7c).
+        def apply(engine, ctx)
+          entry = { "controller" => ctx.controller, "source" => ctx.source, "card" => engine.object(ctx.object).card,
+                    "ability" => ref, "results" => Snapshot.deep_copy(ctx.results || []) }
+          entry["watched"] = @watch.resolve(engine, ctx) if @watch
+          entry["turn"] = engine.state.turn if @this_turn
+          entry["once"] = true if @this_turn == "once" # CR 603.7b: the next time only, and only this turn
+          engine.create_delayed_trigger!(entry)
+        end
+      end
+
+      # A reflexive triggered ability (CR 603.12): "When you do, [effect]". Put it where the action it
+      # depends on is known to have happened, usually a "may"'s `then`. It triggers at once and goes on the
+      # stack the next time a player would receive priority, with its own targets chosen then (CR 603.3d).
+      class ReflexiveTrigger < Effect
+        primitive :effect, :reflexive_trigger,
+                  description: "Creates a reflexive triggered ability (\"when you do, ...\") that triggers immediately, " \
+                               "with the controller and source of the resolving spell or ability. Its `targets` are " \
+                               "chosen as it's put on the stack; its `effects` may name the results of earlier effects " \
+                               "of the creating list. With `if`, it triggers only when the condition holds " \
+                               "(\"when excess damage is dealt this way\").",
+                  rules: %w[603.12 603.12a 603.7d 603.7e 603.3d],
+                  params: { "targets" => "list of target filters", "effects" => "list of effects", "if" => "condition",
+                            "divide" => "amount divided among the targets as it's put on the stack (CR 601.2d)" },
+                  example: { "reflexive_trigger" => { "targets" => ["any_target"],
+                                                      "effects" => [{ "deal_damage" => { "amount" => 2,
+                                                                                         "to" => { "target" => 0 } } }] } }
+
+        # Stands in for the trigger condition on the stack ability ("When you do").
+        WhenYouDo = Data.define do
+          def to_s = "When you do"
+        end
+
+        attr_reader :ref, :delayed_ability
+
+        def self.keys = %w[targets effects divide if]
+        def self.default_to = "you"
+
+        def setup(params, errors, path)
+          @ref = "reflexive:#{path}"
+          targets = Abilities::StackAbility.parse_targets(params, errors, path)
+          effects = Abilities::StackAbility.parse_effects(params, errors, path, targets.size, results_count: @results_count)
+          errors << "#{path}.effects: needs at least one effect" if effects.empty?
+          extras = Abilities::StackAbility.parse_extras(params.slice("divide"), errors, path)
+          Abilities::StackAbility.check_divide(extras, targets, errors, path)
+          @delayed_ability = Abilities::TriggeredAbility.new(targets: targets, effects: effects, trigger: WhenYouDo.new,
+                                                             extras: extras)
+        end
+
+        def nested_effects = delayed_ability.effects
+        def to_s = "reflexive: #{delayed_ability}"
+
+        def apply(engine, ctx)
+          # Created by a replacement's follow-up (Engine::FollowUps), its spell may be long gone: its card is remembered.
+          memory = Selector.memory(engine, ctx)
+          card = engine.state.objects[ctx.object]&.card || memory["source_card"]
+          source = { "id" => ctx.source, "card" => card, "controller" => ctx.controller, "ability" => ref }
+          engine.queue_pending_trigger!(source, nil, { "results" => Snapshot.deep_copy(ctx.results || []),
+                                                       "amounts" => (ctx.amounts || []).dup,
+                                                       "triggering" => memory["triggering"]&.dup }.compact)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Destroy permanents (CR 701.8).
+      class Destroy < Effect
+        primitive :effect, :destroy, description: "Destroy each referenced permanent (it goes to its owner's graveyard).",
+                                     rules: %w[701.8a], params: { "to" => "selector" },
+                                     example: { "destroy" => { "to" => { "target" => 0 } } }
+        def self.keys = %w[to if]
+
+        # CR 702.12b: indestructible permanents aren't destroyed.
+        def apply(engine, ctx)
+          objects(engine, ctx).each do |id|
+            engine.move!(id, :graveyard, reason: "destroy") unless engine.chars(id).keyword?(:indestructible)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Discard N cards of the player's choice (CR 701.9), at random (CR 701.9b), or the whole hand.
+      class Discard < ChoiceEffect
+        primitive :effect, :discard, description: "Each referenced player discards `amount` cards of their choice " \
+                                                  "(default: you). `random: true`: the cards are chosen at random " \
+                                                  "(the game's random number generator), with no decision. " \
+                                                  "`hand: true`: each discards their whole hand at once (\"discard " \
+                                                  "your hand\"; how many is its amount {\"this_way\": n}).",
+                                     rules: %w[701.9a 701.9b], params: { "amount" => "integer", "to" => "selector",
+                                                                         "random" => "boolean",
+                                                                         "hand" => "true: the whole hand" },
+                                     example: { "discard" => { "amount" => 1, "to" => "each_opponent" } }
+        def self.keys = %w[amount to if random hand]
+        def self.amount_optional?(params) = Mechanics.fetch_param(params, :hand) == true
+        def self.default_to = "you"
+
+        def setup(params, errors, path)
+          @random = Mechanics.flag_param(params, :random, errors, path)
+          @hand = Mechanics.flag_param(params, :hand, errors, path)
+          errors << "#{path}: hand and random can't be combined" if @hand && @random
+        end
+
+        def to_s = @hand ? "discard the whole hand → #{to}" : "#{super}#{" at random" if @random}"
+
+        # CR 118.3: "you may discard a card" needs a card to discard; a hand can always be discarded.
+        def possible?(engine, ctx) = @hand || players(engine, ctx).all? { engine.player(it).hand.size >= amount_for(engine, ctx) }
+
+        def run(engine, ctx, locals)
+          return discard_at_random(engine, ctx) if @random
+          return discard_hands(engine, ctx) if @hand
+
+          queue = (locals["players"] ||= players(engine, ctx).flat_map { |i| [i] * amount_for(engine, ctx) })
+          chosen = answers(locals)
+          apply_answers(engine, locals, chosen)
+          while chosen.size < queue.size
+            index = queue[chosen.size]
+            hand = engine.player(index).hand
+            return ask(engine, locals, index, "Discard a card", hand.map { { "type" => "discard", "object" => it } }) unless hand.empty?
+
+            chosen << { "type" => "none" } # nothing left to discard
+            locals["applied"] = chosen.size
+          end
+          :done
+        end
+
+        # CR 701.9b: no one chooses; each card is picked by the game's RNG (so a replay picks the same ones).
+        def discard_at_random(engine, ctx)
+          return :done unless condition.nil? || condition.true?(engine, ctx)
+
+          n = amount_for(engine, ctx)
+          players(engine, ctx).each do |index|
+            hand = engine.player(index).hand
+            picked = engine.state.rng.shuffle!(hand.dup).first(n)
+            picked.each { engine.move!(it, :graveyard, reason: "discard") }
+          end
+          :done
+        end
+
+        # "Discard your hand" (CR 701.9a): all at once, no choice; how many were discarded is its amount.
+        def discard_hands(engine, ctx)
+          return :done unless condition.nil? || condition.true?(engine, ctx)
+
+          players(engine, ctx).each do |index|
+            cards = engine.player(index).hand.dup
+            cards.each { engine.move!(it, :graveyard, reason: "discard") }
+            engine.record_amount!(cards.size)
+          end
+          :done
+        end
+
+        # Performs the discards chosen since the last step.
+        def apply_answers(engine, locals, chosen)
+          (locals["applied"] ||= 0).upto(chosen.size - 1) do |i|
+            answer = chosen[i]
+            engine.move!(answer["object"], :graveyard, reason: "discard") if answer["type"] == "discard"
+          end
+          locals["applied"] = chosen.size
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Draw cards (CR 121).
+      class Draw < Effect
+        primitive :effect, :draw, description: "Each referenced player draws `amount` cards (default: you).",
+                                  rules: %w[121.1 121.2], params: { "amount" => "integer", "to" => "selector" },
+                                  example: { "draw" => { "amount" => 2 } }
+        def self.default_to = "you"
+        def apply(engine, ctx) = players(engine, ctx).each { |i| amount_for(engine, ctx).times { engine.draw!(i) } }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Earthbend N (CR 701.66a): "Target land you control becomes a 0/0 land creature with haste in addition to
+      # its other types. Put N +1/+1 counters on it. When that land dies or is put into exile, return it to the
+      # battlefield tapped under your control." The target is declared on the ability like any other target
+      # (usually `{"land": {"controller": "you"}}`) and named by `to`. The land becomes a creature for as long as
+      # it stays on the battlefield (no duration is stated, CR 611.2a), is the effect's result ("that land"), and
+      # a delayed triggered ability watches it (CR 603.7c). Creating that ability is earthbending (CR 701.66b).
+      class Earthbend < Effect
+        primitive :effect, :earthbend,
+                  description: "Earthbend `amount`: each referenced land (the target, `to`) becomes a 0/0 creature " \
+                               "with haste that's still a land, gets `amount` +1/+1 counters, and when it dies or is " \
+                               "put into exile it returns to the battlefield tapped under your control. The land is " \
+                               "the effect's result.",
+                  rules: %w[701.66a 701.66b 603.7c 611.2a 613.1d 613.4b],
+                  params: { "amount" => "amount", "to" => "selector (the target land, e.g. {\"target\": 0})" },
+                  example: { "earthbend" => { "amount" => 2, "to" => { "target" => 0 } } }
+
+        # The delayed triggered ability: "When that land dies or is put into exile, return it to the battlefield
+        # tapped under your control" ("it" is the card in its new zone, CR 400.7).
+        RETURN = { "when" => { "any_of" => [{ "dies" => { "subject" => "watched" } },
+                                            { "leaves_battlefield" => { "subject" => "watched", "to" => "exile" } }] },
+                   "effects" => [{ "return_to_battlefield" => { "to" => { "triggering" => "object" }, "tapped" => true,
+                                                                "under" => "you" } }] }.freeze
+
+        attr_reader :ref, :delayed_ability
+
+        def setup(_params, errors, path)
+          @ref = "earthbend:#{path}"
+          trigger = Mechanics.build_entry(:trigger, RETURN["when"], errors, "#{path}.when")
+          effects = Abilities::StackAbility.parse_effects(RETURN, errors, path, 0)
+          @delayed_ability = Abilities::TriggeredAbility.new(targets: [].freeze, effects: effects, trigger: trigger)
+        end
+
+        def nested_effects = delayed_ability.effects
+        def to_s = "earthbend #{amount} → #{to}"
+
+        def apply(engine, ctx)
+          lands = objects(engine, ctx).select { engine.chars(it).land? }
+          return if lands.empty?
+
+          n = amount_for(engine, ctx)
+          become_creature!(engine, ctx, lands)
+          lands.each do |id|
+            engine.record_result!(id)
+            engine.add_counters!(engine.object(id), "+1/+1", n, by_player: ctx.controller)
+            engine.create_delayed_trigger!("controller" => ctx.controller, "source" => ctx.source,
+                                           "card" => engine.object(ctx.object).card, "ability" => ref, "watched" => [id])
+            engine.emit Events::KeywordAction.new(player: engine.name(ctx.controller), action: "earthbend", amount: n)
+          end
+        end
+
+        private
+
+        # Layer 4 (a creature in addition to its other types), layer 6 (haste) and layer 7b (base 0/0), for as
+        # long as it stays on the battlefield; the same continuous effects `become` creates.
+        def become_creature!(engine, ctx, lands)
+          lasting = { "duration" => "permanent" }
+          engine.add_continuous_effect!("add_types", ctx, lands,
+                                        { "types" => ["creature"], "supertypes" => [], "subtypes" => [] }.merge(lasting))
+          engine.add_continuous_effect!("grant", ctx, lands, { "keywords" => ["haste"] }.merge(lasting))
+          engine.add_continuous_effect!("base_power_toughness", ctx, lands, { "power" => 0, "toughness" => 0 }.merge(lasting))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # "You get an emblem with '...'" (CR 114.1-114.4): each referenced player gets an emblem in the command
+      # zone with the `abilities`. They are part of this card's data, referenced "<this effect's ref>:<j>"
+      # (CardDefinition#effect_granted), and work from the command zone for the rest of the game (Engine::Emblems).
+      class CreateEmblem < Effect
+        KINDS = %i[triggered static player_rule].freeze
+
+        primitive :effect, :create_emblem,
+                  description: "Each referenced player (default you) gets an emblem with the `abilities` (triggered, " \
+                               "static or player_rule abilities). An emblem is in the command zone for the rest of the " \
+                               "game; its abilities work there, and \"this emblem\" is the source of what they do.",
+                  rules: %w[114.1 114.2 114.3 114.4 113.6p],
+                  params: { "abilities" => "list of triggered, static or player_rule abilities", "to" => "selector" },
+                  example: { "create_emblem" => { "abilities" => [
+                    { "static" => { "affects" => { "each" => "creature", "controller" => "you" },
+                                    "pump" => { "power" => 2, "toughness" => 2 } } }
+                  ] } }
+
+        attr_reader :ref, :granted_abilities
+
+        def self.keys = %w[abilities to if]
+        def self.default_to = "you"
+
+        def setup(params, errors, path)
+          @ref = "emblem:#{path}"
+          list = Mechanics.list_param(params, :abilities, errors, path)
+          errors << "#{path}.abilities: needs at least one ability" if list.empty?
+          @granted_abilities = list.each_with_index.filter_map do |entry, j|
+            ability = Mechanics.build_entry(:ability, entry, errors, "#{path}.abilities[#{j}]")
+            next ability if ability.nil? || KINDS.include?(ability.kind)
+
+            errors << "#{path}.abilities[#{j}]: an emblem's abilities are #{KINDS.join(", ")} abilities"
+            nil
+          end.freeze
+        end
+
+        def nested_effects = granted_abilities.flat_map(&:try_effects)
+
+        def apply(engine, ctx)
+          card = engine.object(ctx.object).card
+          players(engine, ctx).each { engine.create_emblem!(it, card, ref) }
+        end
+
+        def to_s = "gets an emblem with \"#{granted_abilities.join("; ")}\" → #{to}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Endure N (CR 701.63a): the permanent's controller creates an N/N white Spirit creature token unless
+      # they put N +1/+1 counters on that permanent. The choice is an `effect_choice` ("counters" is offered
+      # only while the permanent is on the battlefield). Endure 0 does nothing (CR 701.63b). N is any amount
+      # ("endures X", "where X is the number of counters on this creature"), fixed as the effect starts; the
+      # token's power and toughness are copiable values the effect gives it (CR 707.2, 111.4).
+      class Endure < ChoiceEffect
+        primitive :effect, :endure,
+                  description: "Each referenced permanent (default: this one) endures `amount`: its controller puts " \
+                               "that many +1/+1 counters on it, or creates an N/N white Spirit creature token.",
+                  rules: %w[701.63a 701.63b 707.2 111.4],
+                  params: { "amount" => "amount (2, \"x\", {\"counters\": ...})",
+                            "to" => "selector of permanents (default self)" },
+                  example: { "endure" => { "amount" => 2 } }
+
+        SPIRIT = { "name" => "Spirit", "types" => ["creature"], "subtypes" => ["spirit"], "colors" => ["W"],
+                   "power" => 0, "toughness" => 0 }.freeze
+
+        def self.keys = %w[amount to if]
+        def self.default_to = "self"
+        def self.spirit = @spirit ||= CardDefinition.token(SPIRIT)
+
+        def created_tokens = [Endure.spirit]
+
+        def run(engine, ctx, locals)
+          unless locals.key?("queue")
+            return :done unless condition.nil? || condition.true?(engine, ctx)
+
+            locals["n"] = [amount_for(engine, ctx), 0].max
+            locals["queue"] = locals["n"].zero? ? [] : refs(engine, ctx).select { engine.state.objects.key?(it) }
+          end
+          n = locals["n"]
+          while (id = locals["queue"].first)
+            perm = engine.object(id)
+            index = perm.zone == :battlefield ? perm.controller : ctx.controller
+            answer = answers(locals).first
+            if answer.nil? && perm.zone == :battlefield
+              return ask(engine, locals, index, "Endure #{n}: put #{n} +1/+1 counters on it, or create a #{n}/#{n} Spirit?",
+                         [{ "type" => "counters", "object" => id }, { "type" => "spirit" }])
+            end
+            answer&.[]("type") == "counters" ? engine.add_counters!(perm, "+1/+1", n, by_player: index) : spirit!(engine, index, n)
+            locals["queue"].shift
+            locals.delete("answers")
+          end
+          :done
+        end
+
+        def to_s = "endure #{amount} → #{to}"
+
+        private
+
+        # An N/N Spirit: N is part of the token's copiable values (Engine::Copies, "copy_except").
+        def spirit!(engine, index, n)
+          engine.create_token!(Endure.spirit, index, memory: { "copy_except" => { "power" => n, "toughness" => n } })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Exile (CR 406, 701.13). `link`: the card is "exiled with" the source, for its linked abilities
+      # (CR 607.2a). `until_source_leaves`: it returns once the source leaves the battlefield (CR 610.3).
+      class Exile < ZoneEffect
+        primitive :effect, :exile,
+                  description: "Exile each referenced permanent, spell, or card in a graveyard or hand. `link: true`: the cards " \
+                               "are exiled with the source, for its \"exiled with\" abilities (the `exiled_with` selector). " \
+                               "`until_source_leaves: true`: they return to the battlefield under their owners' control " \
+                               "when the source leaves the battlefield; if it already has, nothing is exiled.",
+                  rules: %w[406.1 701.13a 607.2a 406.6 610.3 610.3a 610.3b 610.3c],
+                  params: { "to" => "selector", "link" => "boolean", "until_source_leaves" => "boolean" },
+                  example: { "exile" => { "to" => { "target" => 0 } } }
+
+        attr_reader :link, :until_leaves
+
+        def self.keys = %w[to link until_source_leaves if]
+        def self.zone = :exile
+        # A spell too ("exile target spell", CR 701.13a).
+        def self.from_zones = %i[battlefield graveyard hand stack]
+
+        def setup(params, errors, path)
+          @link = Mechanics.flag_param(params, "link", errors, path)
+          @until_leaves = Mechanics.flag_param(params, "until_source_leaves", errors, path)
+        end
+
+        def to_s = "exile#{" until the source leaves" if until_leaves}#{" (linked)" if link} → #{to}"
+
+        # CR 610.3a-b: if the source has already left the battlefield, the object doesn't move.
+        def apply(engine, ctx)
+          return if until_leaves && !engine.state.battlefield.include?(ctx.source)
+
+          super
+        end
+
+        def move(engine, ctx, id)
+          fresh = super or return
+          engine.link_exiled!(ctx.source, fresh.id) if link || until_leaves
+          return unless until_leaves
+
+          (engine.object(ctx.source).memory[Linked::UNTIL_LEAVES] ||= []) << fresh.id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # "Take an extra turn after this one." (CR 500.7)
+      class ExtraTurn < Effect
+        primitive :effect, :extra_turn,
+                  description: "Each referenced player (default you) takes an extra turn after this one. Extra " \
+                               "turns are taken most recently created first.",
+                  rules: %w[500.7],
+                  params: { "to" => "selector" },
+                  example: { "extra_turn" => { "if" => { "began_extra_turn" => false } } }
+
+        def self.keys = %w[to if]
+        def self.default_to = "you"
+
+        def apply(engine, ctx) = players(engine, ctx).each { engine.add_extra_turn!(it) }
+        def to_s = "take an extra turn after this one → #{to}"
+      end
+
+      # "Target opponent skips their next X turns." (CR 614.10)
+      class SkipTurns < Effect
+        primitive :effect, :skip_turns,
+                  description: "Each referenced player skips their next `amount` turns (extra turns included): " \
+                               "each of those turns doesn't happen, and the next player in turn order takes theirs. " \
+                               "Several skips add up.",
+                  rules: %w[614.1b 614.10 614.10a],
+                  params: { "amount" => "amount", "to" => "selector" },
+                  example: { "skip_turns" => { "amount" => 1, "to" => { "target" => 0 } } }
+
+        def apply(engine, ctx)
+          n = amount_for(engine, ctx)
+          players(engine, ctx).each { engine.skip_turns!(it, n) }
+        end
+
+        def to_s = "skip the next #{amount} turn(s) → #{to}"
+      end
+
+      # "After this phase, there is an additional combat phase", "... followed by an additional main phase",
+      # "After this main phase, there are two additional combat phases." (CR 500.8)
+      class AdditionalPhases < Effect
+        primitive :effect, :additional_phases,
+                  description: "Adds `phases` (in order; each \"combat\" or \"main\") directly after the current " \
+                               "phase of this turn. Phases added after the same phase come most recently created " \
+                               "first. An added main phase is a postcombat main phase. `attackers`: only creatures " \
+                               "matching this filter can attack during the (first) added combat phase.",
+                  rules: %w[500.8 505.1 508.1c],
+                  params: { "phases" => "list of \"combat\" | \"main\"", "attackers" => "creature filter" },
+                  example: { "additional_phases" => { "phases" => %w[combat main] } }
+
+        attr_reader :phases, :attackers
+
+        def self.keys = %w[phases attackers if]
+        def self.default_to = "you"
+
+        def setup(params, errors, path)
+          @attackers = Mechanics.fetch_param(params, :attackers)
+          Mechanics.build_entry(:filter, @attackers, errors, "#{path}.attackers") unless @attackers.nil?
+          @phases = Mechanics.list_param(params, :phases, errors, path)
+          return if !@phases.empty? && @phases.all? { Engine::ADDED_PHASES.key?(it) }
+
+          errors << "#{path}.phases: must be a non-empty list of \"combat\" | \"main\""
+        end
+
+        def apply(engine, _ctx) = engine.add_phases!(phases.dup, attackers: attackers)
+
+        def to_s
+          only = " (only #{Mechanics.build_entry(:filter, attackers, [], "")} can attack)" if attackers
+          "after this phase, additional #{phases.join(" and ")} phase#{"s" if phases.size > 1}#{only}"
+        end
+      end
+
+      # "End the turn." (CR 725.1)
+      class EndTheTurn < Effect
+        primitive :effect, :end_the_turn,
+                  description: "Ends the turn: triggered abilities not yet on the stack cease to exist, every object on " \
+                               "the stack is exiled (this spell too, so its later effects don't happen), state-based " \
+                               "actions are checked, combat ends and the game skips to the cleanup step. Abilities " \
+                               "that trigger meanwhile go on the stack during cleanup, followed by another cleanup step.",
+                  rules: %w[725.1 725.1a 725.1b 725.1c 725.1d 725.1e 725.1f 514.3a],
+                  example: "end_the_turn"
+
+        def self.keys = %w[if]
+        def self.default_to = "you"
+
+        def apply(engine, _ctx) = engine.end_the_turn!
+        def to_s = "end the turn"
+      end
+    end
+
+    class Condition
+      # "If you haven't begun an extra turn this game" (CR 500.7): {"began_extra_turn": false}.
+      class BeganExtraTurn
+        def initialize(wanted)
+          @wanted = wanted
+          freeze
+        end
+
+        def true?(engine, ctx) = engine.began_extra_turn?(ctx.controller) == @wanted
+        def to_s = @wanted ? "you've begun an extra turn this game" : "you haven't begun an extra turn this game"
+      end
+
+      # "If it's the first combat phase of the turn" (CR 500.8): {"first_combat_phase": true}.
+      class FirstCombatPhase
+        def self.build(data, errors, path)
+          Mechanics.check_keys(data, %w[first_combat_phase], errors, path)
+          errors << "#{path}.first_combat_phase: must be true or false" unless [true, false].include?(data["first_combat_phase"])
+          new(data["first_combat_phase"] != false)
+        end
+
+        def initialize(wanted)
+          @wanted = wanted
+          freeze
+        end
+
+        def true?(engine, _ctx) = engine.first_combat_phase? == @wanted
+        def to_s = @wanted ? "it's the first combat phase of the turn" : "it isn't the first combat phase of the turn"
+      end
+    end
+  end
+end