enjine 0.1.0 → 0.2.0

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Abilities
+      # "Plot [cost]" (CR 702.170a-b, 116.2k): any time you have priority during your turn, if the stack is empty
+      # and it's your main phase, you may pay `cost` and exile this card from your hand (a special action,
+      # `{type: "special_action"}`). It becomes a plotted card (Effects::Plot.plot!): its owner may cast it
+      # without paying its mana cost during their main phase while the stack is empty, on a later turn
+      # (cast option `via: "plotted"`, Engine::AltCasting#plotted_methods).
+      class Plot < Primitive
+        primitive :ability, :plot,
+                  description: "Plot `cost`: during your main phase, while the stack is empty, you may pay `cost` and " \
+                               "exile this card from your hand (special action `{type: \"special_action\"}`). It becomes " \
+                               "plotted: on a later turn you may cast it from exile without paying its mana cost, " \
+                               "during your main phase while the stack is empty (cast option `via: \"plotted\"`).",
+                  rules: %w[702.170a 702.170b 702.170d 116.2k],
+                  params: { "cost" => "mana cost string" },
+                  example: { "plot" => { "cost" => "{1}{R}" } }
+
+        attr_reader :special_cost
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[cost], errors, path)
+          new(Costs::ManaPayment.build(Mechanics.fetch_param(params, :cost).to_s, errors, "#{path}.cost").mana_cost)
+        end
+
+        def initialize(cost)
+          super()
+          @special_cost = cost
+          freeze
+        end
+
+        def kind = :plot
+        def mana_ability? = false
+        def allowed_types = nil
+        def try_effects = []
+        def to_s = "Plot #{special_cost}"
+
+        # CR 702.170a: during your turn, in your main phase, with an empty stack (as a sorcery, whatever its type).
+        def special_allowed?(engine, obj, index) = obj.zone == :hand && engine.sorcery_timing?(index)
+
+        def special!(engine, obj, _index) = Effects::Plot.plot!(engine, obj.id)
+      end
+    end
+
+    module Effects
+      # "It becomes plotted" / "plot that card" (CR 702.170c-d): the card is exiled face up (or stays exiled) and
+      # becomes a plotted card, remembering the turn. Its owner may cast it without paying its mana cost on a later
+      # turn, during their main phase while the stack is empty.
+      class Plot < Effect
+        primitive :effect, :plot,
+                  description: "Each referenced card or spell is exiled (if it isn't already) and becomes plotted: its " \
+                               "owner may cast it from exile without paying its mana cost during their main phase while " \
+                               "the stack is empty, on any later turn (cast option `via: \"plotted\"`).",
+                  rules: %w[702.170c 702.170d 406.1],
+                  params: { "to" => "selector (a spell, a card, or an exiled card such as {\"result\": 0})" },
+                  example: { "plot" => { "to" => { "target" => 0 } } }
+
+        def self.keys = %w[to if]
+
+        def self.plot!(engine, id)
+          obj = engine.state.objects[id] or return
+          fresh = obj.zone == :exile ? obj : engine.move!(id, :exile, reason: "plot")
+          fresh.memory["plotted"] = engine.state.turn if fresh&.zone == :exile
+        end
+
+        def apply(engine, ctx)
+          refs(engine, ctx).each do |id|
+            obj = engine.state.objects[id]
+            Plot.plot!(engine, id) if obj && !obj.ability? && obj.kind == "card"
+          end
+        end
+
+        def to_s = "plot → #{to}"
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/triggers/casting.rb

@@ -173,14 +173,16 @@ module Enjine
                                "mana ability. `source`: optional filter on the source's card; `name: \"chosen\"`: only a " \
                                "source with the name chosen as this permanent entered. `exhaust: true`: only an exhaust " \
                                "ability (\"whenever you activate an exhaust ability\", CR 702.177). `boast: true`: only a " \
-                               "boast ability (\"whenever a creature you control boasts\", CR 702.142b).",
-                  rules: %w[602.2 605.1a 603.2 201.4 702.177a 702.142b],
+                               "boast ability (\"whenever a creature you control boasts\", CR 702.142b). `loyalty: " \
+                               "true`: only a loyalty ability (CR 606).",
+                  rules: %w[602.2 605.1a 603.2 201.4 702.177a 702.142b 606.1],
                   params: { "controller" => PLAYERS.join(" | "), "source" => "card filter", "name" => "\"chosen\"",
-                            "exhaust" => "true: only exhaust abilities", "boast" => "true: only boast abilities" },
+                            "exhaust" => "true: only exhaust abilities", "boast" => "true: only boast abilities",
+                            "loyalty" => "true: only loyalty abilities" },
                   example: { "activates_ability" => { "controller" => "opponent" } }
 
-        def self.keys = %w[controller source name exhaust boast]
-        KINDS = { "exhaust" => :exhaust?, "boast" => :boast? }.freeze
+        def self.keys = %w[controller source name exhaust boast loyalty]
+        KINDS = { "exhaust" => :exhaust?, "boast" => :boast?, "loyalty" => :loyalty? }.freeze
         def event_class = Events::AbilityActivated
 
         def setup(params, errors, path)
@@ -202,7 +204,7 @@ module Enjine
 
         def to_s
           what = "#{@kinds.map { "#{it.to_s.delete("?")} " }.join}ability"
-          "Whenever #{who} activate#{"s" unless @controller == "you"} #{what.start_with?("b") ? "a" : "an"} #{what}#{chosen_words}"
+          "Whenever #{who} activate#{"s" unless @controller == "you"} #{what.match?(/\A[aeiou]/) ? "an" : "a"} #{what}#{chosen_words}"
         end
 
         private

data/lib/enjine/mechanics/values.rb

@@ -9,10 +9,14 @@ module Enjine
     #                                                 how many the first effect moved or created, e.g. cards drawn)
     #   {"power": selector} / {"toughness": ...}      total power / toughness ("Picard's power": {"power": "self"})
     #   {"greatest_power" | "greatest_toughness": selector}  the greatest power / toughness among them (0 for none)
-    #   {"hand_size" | "life" | "graveyard_size": player selector}
+    #   {"hand_size" | "life" | "graveyard_size" | "library_size": player selector}
     #   {"distinct_names": selector}                  how many different names they have (strange new worlds)
     #   {"mana_value": selector}                      their total mana value (a spell's X counts on the stack; a spell
     #                                                 countered by the resolving one: as it last existed, CR 608.2h)
+    #   {"greatest_mana_value": selector}             the greatest mana value among them (0 for none, CR 202.3)
+    #   {"sacrificed": "power" | "toughness" | "mana_value"}  of the permanents sacrificed to pay the resolving
+    #                                                 spell's or ability's cost, as they last existed (CR 601.2h, 608.2h)
+    #   {"card_types": selector}                      how many different card types among them (delirium, CR 205.2a)
     #   {"distinct_types": selector}                  how many different creature types they have (CR 205.3m)
     #   {"distinct_colors": selector}                 how many colors among them (CR 105.2, 202.2)
     #   {"distinct_land_types": selector}             how many basic land types among them (domain, CR 305.6)
@@ -31,14 +35,16 @@ module Enjine
     #   {"mana_spent": {"of": ..., "color" | "colors": ...}}  mana spent to cast a spell (CR 601.2h), see mana_spent.rb
     #   {"times": [a, b]} / {"plus": [a, b]} / {"divide": [a, b]}   arithmetic on amounts; division rounds down
     #                                                 (CR 107.1a). "-X" is {"times": ["x", -1]}.
-    # A source that has left the battlefield is used as it last existed (CR 608.2h).
+    # A source that has left the battlefield is used as it last existed (CR 608.2h), and so is any object the
+    # power, toughness or mana value of which is read after it left the battlefield during the resolving
+    # spell or ability (a destroyed target, or {"result": n} of a sacrifice).
     class Amount
       SELECTOR_KINDS = %w[count power toughness greatest_power hand_size life graveyard_size distinct_names distinct_types
                           distinct_colors distinct_land_types distinct_planeswalker_types
                           life_gained_this_turn life_lost_this_turn dilemmas_this_turn returned_this_turn
                           cards_drawn_this_turn cards_discarded_this_turn spells_cast_this_game speed
                           noncombat_damage_this_turn noncombat_damage_last_turn turns_taken greatest_toughness
-                          mana_value].freeze
+                          mana_value greatest_mana_value card_types library_size].freeze
       ARITHMETIC = %w[times plus divide].freeze
       BASIC_LAND_TYPES = %i[plains island swamp mountain forest].freeze # CR 305.6
       # Object history lists: kind -> turn_log key (Engine::TurnHistory).
@@ -46,7 +52,7 @@ module Enjine
                    "sacrificed_this_turn" => "sacrificed", "attackers_this_turn" => "attackers",
                    "exiled_this_turn" => "exiled" }.freeze
       KINDS = (SELECTOR_KINDS + ARITHMETIC + DEPARTED.keys + %w[counters spells_cast_this_turn lands_played_this_turn this_way
-                                                                mana_spent]).freeze
+                                                                mana_spent sacrificed]).freeze
       # Player history counters: kind -> turn_log/game_log key.
       HISTORY = { "life_gained_this_turn" => "life_gained", "life_lost_this_turn" => "life_lost",
                   "dilemmas_this_turn" => "dilemmas", "returned_this_turn" => "returned",
@@ -74,6 +80,7 @@ module Enjine
         return Departed.build(kind, ref, errors, "#{path}.#{kind}") if DEPARTED.key?(kind)
         return ThisWay.build(ref, errors, "#{path}.#{kind}", results_count) if kind == "this_way"
         return ManaSpent.build(ref, errors, "#{path}.#{kind}", **context) if kind == "mana_spent" # mana_spent.rb
+        return Sacrificed.build(ref, errors, "#{path}.#{kind}") if kind == "sacrificed"
 
         new(kind, Selector.build(ref, errors, "#{path}.#{kind}", **context))
       end
@@ -96,15 +103,9 @@ module Enjine
         when "count" then refs.size
         when "power", "toughness" then refs.empty? ? Amount.last_known(engine, ctx, @selector, @kind) : stats(engine, refs).sum
         when "greatest_power", "greatest_toughness" then stats(engine, refs).max.to_i
-        when "mana_value" then refs.sum do
-          Amount.mana_value(engine, engine.state.objects[it]) || engine.resolving_last_known(it)&.[]("mana_value").to_i
-        end
-        when "distinct_names" then live(engine, refs).map { engine.chars(it).name }.uniq.size
-        when "distinct_types" then live(engine, refs).flat_map { Amount.creature_types(engine.chars(it)) }.uniq.size
-        when "distinct_colors" then live(engine, refs).flat_map { engine.chars(it).colors }.uniq.size # CR 105.2
-        when "distinct_land_types" then (live(engine, refs).flat_map { engine.chars(it).subtypes } & BASIC_LAND_TYPES).size
-        when "distinct_planeswalker_types" # CR 205.3j: a planeswalker's subtypes are planeswalker types
-          live(engine, refs).flat_map { (c = engine.chars(it)).type?(:planeswalker) ? c.subtypes : [] }.uniq.size
+        when "mana_value" then mana_values(engine, refs).sum
+        when "greatest_mana_value" then mana_values(engine, refs).max.to_i
+        when *DISTINCT then distinct(live(engine, refs).map { engine.chars(it) })
         else players(engine, refs).sum { player_value(engine, it) }
         end
       end
@@ -133,6 +134,17 @@ module Enjine
         lki ? lki[key].to_i : 0
       end
 
+      # How an object last existed on the battlefield if it left during the resolving spell or ability: by its
+      # old id (a destroyed target), or, for what an earlier effect moved (`moved`: a {"result": n} selector), as
+      # the new object it became (CR 400.7). A spell countered by the resolving one, as it last existed on the
+      # stack (Engine::TurnHistory#remember_spell!). Nil otherwise: a card in a graveyard looked at for itself is
+      # the card there.
+      def self.left_battlefield(engine, ref, moved: false)
+        return engine.departed_last_known(ref) if moved && engine.departed_last_known(ref)
+
+        engine.state.objects.key?(ref) ? nil : engine.resolving_last_known(ref)
+      end
+
       # How a source that has left the battlefield last existed: remembered by the resolving ability, or,
       # while its leaves-the-battlefield trigger is being checked (CR 603.4, 603.10a), the engine's.
       def self.source_lki(engine, ctx)
@@ -141,10 +153,42 @@ module Enjine
 
       private
 
+      DISTINCT = %w[card_types distinct_names distinct_types distinct_colors distinct_land_types
+                    distinct_planeswalker_types].freeze
+      private_constant :DISTINCT
+
+      # How many different card types, names, creature types, colors, basic land types or planeswalker types
+      # the objects with these characteristics have between them.
+      def distinct(chars)
+        case @kind
+        when "card_types" then chars.flat_map(&:types).uniq.size # CR 205.2a
+        when "distinct_names" then chars.map(&:name).uniq.size
+        when "distinct_types" then chars.flat_map { Amount.creature_types(it) }.uniq.size
+        when "distinct_colors" then chars.flat_map(&:colors).uniq.size # CR 105.2
+        when "distinct_land_types" then (chars.flat_map(&:subtypes) & BASIC_LAND_TYPES).size
+        else chars.flat_map { it.type?(:planeswalker) ? it.subtypes : [] }.uniq.size # CR 205.3j
+        end
+      end
+
       def live(engine, refs) = refs.select { engine.state.objects.key?(it) }
 
+      # Each one's mana value; one that has left as it last existed (CR 608.2h).
+      def mana_values(engine, refs)
+        refs.map do |ref|
+          lki = Amount.left_battlefield(engine, ref, moved: @selector.kind == :result)
+          lki ? lki["mana_value"].to_i : Amount.mana_value(engine, engine.state.objects[ref]) || 0
+        end
+      end
+
+      # Each one's power or toughness; one that left the battlefield during the resolving spell or ability as it
+      # last existed (CR 608.2h), one that's simply gone not at all.
       def stats(engine, refs)
-        live(engine, refs).map { engine.public_send(@kind.end_with?("toughness") ? :toughness : :power, engine.object(it)) }
+        key = @kind.end_with?("toughness") ? "toughness" : "power"
+        refs.filter_map do |ref|
+          if (lki = Amount.left_battlefield(engine, ref, moved: @selector.kind == :result)) then lki[key].to_i
+          elsif engine.state.objects.key?(ref) then engine.public_send(key, engine.object(ref))
+          end
+        end
       end
 
       def players(engine, refs) = refs.filter_map { Filters.player_index(engine, it) }
@@ -155,6 +199,7 @@ module Enjine
         when "life" then engine.player(index).life
         when "speed" then engine.speed(index) # CR 702.179f: 0 without speed
         when "graveyard_size" then engine.player(index).graveyard.size
+        when "library_size" then engine.player(index).library.size # CR 401.1
         when "spells_cast_this_game" then engine.game_log(index).fetch("spells", 0)
         when "turns_taken" then engine.game_log(index).fetch("turns", 0) # this turn included, if it's theirs
         when *LAST_TURN.keys then engine.last_turn_log(index).fetch(LAST_TURN.fetch(@kind), 0)
@@ -180,6 +225,29 @@ module Enjine
         def to_s = "that many"
       end
 
+      # {"sacrificed": "power" | "toughness" | "mana_value"}: "the sacrificed creature's power" — the total of the
+      # permanents sacrificed to pay the resolving spell's or ability's cost, as they last existed (CR 601.2h,
+      # 608.2h; recorded by Costs::SacrificePermanent). 0 when none was.
+      class Sacrificed
+        KEYS = %w[power toughness mana_value].freeze
+
+        def self.build(key, errors, path)
+          return new(key) if KEYS.include?(key)
+
+          errors << "#{path}: must be #{KEYS[0..-2].join(", ")} or #{KEYS.last}"
+          Fixed.new(0)
+        end
+
+        def initialize(key)
+          @key = key
+          freeze
+        end
+
+        def reads_power? = @key != "mana_value"
+        def value(engine, ctx) = (engine.state.objects[ctx.object]&.paid || []).sum { it[@key].to_i }
+        def to_s = "the sacrificed permanent's #{@key.tr("_", " ")}"
+      end
+
       # A fixed number.
       class Fixed
         attr_reader :n

data/lib/enjine/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Enjine
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
   # Comprehensive Rules document this engine follows.
   RULES_VERSION = "2026-11-06"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: enjine
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Mehmet Cetin
@@ -30,6 +30,7 @@ files:
 - docs/guides/api.md
 - docs/guides/card-data-format.md
 - docs/guides/deck-builder.md
+- docs/plans/dsl-gaps.md
 - docs/plans/standard.md
 - docs/reference/abilities.md
 - docs/reference/costs.md
@@ -91,6 +92,7 @@ files:
 - lib/enjine/engine/combat.rb
 - lib/enjine/engine/copies.rb
 - lib/enjine/engine/damage.rb
+- lib/enjine/engine/defined_power_toughness.rb
 - lib/enjine/engine/designations.rb
 - lib/enjine/engine/emblems.rb
 - lib/enjine/engine/entering.rb
@@ -231,6 +233,7 @@ files:
 - lib/enjine/mechanics/keywords/kicker.rb
 - lib/enjine/mechanics/keywords/mobilize_and_firebending.rb
 - lib/enjine/mechanics/keywords/paradigm.rb
+- lib/enjine/mechanics/keywords/plot.rb
 - lib/enjine/mechanics/keywords/power_up.rb
 - lib/enjine/mechanics/keywords/protection.rb
 - lib/enjine/mechanics/keywords/prowess.rb