enjine 0.1.0

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative "crew"
+
+module Enjine
+  module Mechanics
+    module Costs
+      # The cost of saddle N (CR 702.171a): "Tap any number of other untapped creatures you control with total
+      # power N or greater", chosen exactly like crew's. Each creature tapped for it saddles the permanent
+      # (CR 702.171c).
+      class Saddle < Crew
+        def choose!(engine, option) = super.merge("saddles" => true)
+        def action = :saddle
+
+        def pay_chosen!(engine, object, entries)
+          entries.each { engine.emit Events::SaddledMount.new(object: it["object"], mount: object.id) }
+        end
+      end
+    end
+
+    module Effects
+      # "[It] becomes saddled until end of turn" (CR 702.171a-b): the saddled designation, which stays until the
+      # turn ends or the permanent leaves the battlefield and isn't copiable (it lives on the object, stamped
+      # with the turn, Engine#saddled?). The effect of a saddle ability, and of cards that saddle a Mount
+      # without its saddle ability.
+      class BecomeSaddled < Effect
+        primitive :effect, :become_saddled,
+                  description: "Each referenced permanent (default: this one) becomes saddled until end of turn " \
+                               "(filters: `\"saddled\": true`).",
+                  rules: %w[702.171a 702.171b],
+                  params: { "to" => "selector of permanents (default self)" },
+                  example: { "become_saddled" => { "to" => { "target" => 0 } } }
+
+        def self.keys = %w[to if]
+        def self.default_to = "self"
+        def to_s = "becomes saddled until end of turn → #{to}"
+
+        def apply(engine, ctx)
+          riders = (engine.object(ctx.object).paid || []).select { it["saddles"] }.map { it["object"] }
+          objects(engine, ctx).each do |id|
+            engine.saddle!(id)
+            engine.emit Events::BecameSaddled.new(object: id, riders: riders)
+          end
+        end
+      end
+    end
+
+    module Abilities
+      # Saddle N (CR 702.171a): an activated ability of a Mount, at sorcery speed. Written {"saddle": {"power": N}}.
+      class Saddle < ActivatedAbility
+        primitive :ability, :saddle,
+                  description: "Saddle N: tap any number of other untapped creatures you control with total power N " \
+                               "or more (chosen one at a time; `done` once the total is enough): this permanent " \
+                               "becomes saddled until end of turn. Activate only as a sorcery.",
+                  rules: %w[702.171a 702.171b 702.171c],
+                  params: { "power" => "integer >= 1 (the N of saddle N)" },
+                  example: { "saddle" => { "power" => 2 } }
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[power], errors, path)
+          n = Mechanics.integer_param(params, :power, errors, path, min: 1)
+          new(sorcery: true, targets: [].freeze, costs: [Costs::Saddle.new(n)].freeze,
+              effects: [Effects::BecomeSaddled.new(to: Selector.new(:self), params: {}, errors: [], path: path)].freeze)
+        end
+
+        def power = costs.first.power
+        def to_s = "Saddle #{power}"
+      end
+    end
+
+    module Triggers
+      # "Whenever this creature becomes saddled" (CR 702.171b): a saddle ability (or another effect) saddled it.
+      class BecomesSaddled < BecomesCrewed
+        primitive :trigger, :becomes_saddled,
+                  description: "The subject becomes saddled (its saddle ability resolved, or an effect saddled it).",
+                  rules: %w[702.171b 603.2],
+                  params: { "subject" => "\"self\" (default) or {\"each\": filter, ...}" },
+                  example: { "becomes_saddled" => {} }
+
+        def event_class = Events::BecameSaddled
+
+        def occurrences(engine, event, source)
+          return [] unless match?(engine, event, source)
+
+          obj = engine.object(event.object)
+          [{ "object" => obj.id, "player" => obj.controller, "card" => obj.card, "amount" => event.riders.size }]
+        end
+
+        def to_s = "Whenever #{@subject} becomes saddled"
+      end
+
+      # "Whenever this creature saddles a Mount" (CR 702.171c): it was tapped to pay a saddle cost. The event's
+      # object for the effects ("that Mount") is the Mount.
+      class SaddlesMount < CrewsVehicle
+        primitive :trigger, :saddles_mount,
+                  description: "The subject (a creature) saddles a Mount: it's tapped to pay that Mount's saddle " \
+                               "cost. {\"triggering\": \"object\"} is the Mount.",
+                  rules: %w[702.171c 603.2],
+                  params: { "subject" => "\"self\" (default) or {\"each\": filter, ...}" },
+                  example: { "saddles_mount" => { "subject" => "self" } }
+
+        def event_class = Events::SaddledMount
+
+        def occurrences(engine, event, source)
+          return [] unless match?(engine, event, source)
+
+          mount = engine.state.objects[event.mount]
+          [{ "object" => event.mount, "player" => engine.object(event.object).controller, "card" => mount&.card }.compact]
+        end
+
+        def to_s = "Whenever #{@subject} saddles a Mount"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # "Your speed increases by 1" (CR 702.179c-d): a player without speed gets that much; never above 4.
+      class IncreaseSpeed < Effect
+        def self.keys = %w[to]
+        def apply(engine, ctx) = engine.increase_speed!(ctx.controller, 1)
+        def to_s = "your speed increases by 1"
+      end
+    end
+
+    module Keywords
+      # Start your engines! (CR 702.179a, 704.5aa): a player who controls a permanent with it and has no speed
+      # gets speed 1 (a state-based action). The inherent triggered ability of a player with speed (CR 702.179d)
+      # has no source; the engine (Engine::Speed) puts it on the stack as this keyword's ability
+      # "keyword:start_your_engines", which never triggers from the permanent itself (its zone is :rules).
+      class StartYourEngines < Primitive
+        primitive :keyword, :start_your_engines,
+                  description: "If you control this permanent and have no speed, your speed becomes 1. Once you have " \
+                               "speed, it increases by 1 (to at most 4) once on each of your turns when one or more " \
+                               "opponents lose life. Pair with `max_speed` abilities and the `speed` amount.",
+                  rules: %w[702.179a 702.179b 702.179c 702.179d 704.3],
+                  example: { "keywords" => ["start_your_engines"] }
+
+        # "Whenever one or more opponents lose life during your turn" (matched by Engine::Speed#watch_speed!).
+        class OpponentsLoseLife
+          def watches?(_event) = false
+          def leaves_battlefield? = false
+          def to_s = "Whenever one or more opponents lose life during your turn"
+        end
+
+        def self.intrinsic_abilities
+          @intrinsic_abilities ||= [
+            Abilities::TriggeredAbility.new(
+              trigger: OpponentsLoseLife.new.freeze, targets: [].freeze, limit: "once_each_turn", zone: :rules,
+              condition: Condition.build({ "amount" => { "speed" => "you" }, "at_most" => 3 }, [], "speed"),
+              effects: [Effects::IncreaseSpeed.new(to: nil, params: {}, errors: [], path: "speed")].freeze
+            )
+          ].freeze
+        end
+      end
+    end
+
+    module Abilities
+      # Max speed (CR 702.178a): "As long as your speed is 4, this object has [ability]." Like a station symbol,
+      # its keywords and abilities are part of the object only while it applies; a card that isn't on the
+      # battlefield uses its owner's speed (CR 702.178b, 113.6c: e.g. an ability activated from the graveyard).
+      class MaxSpeed < Primitive
+        primitive :ability, :max_speed,
+                  description: "While your speed is 4 (max speed), this object has `keywords` and `abilities` (any " \
+                               "kind: activated, triggered, static, mana; an ability with a graveyard cost works from " \
+                               "your graveyard).",
+                  rules: %w[702.178a 702.178b 702.179e 113.6c],
+                  params: { "keywords" => "list of keywords", "abilities" => "list of abilities" },
+                  example: { "max_speed" => { "abilities" => [{ "activated" => { "cost" => ["tap"],
+                                                                                 "effects" => [{ "draw" => { "amount" => 1 } }] } }] } }
+
+        attr_reader :keywords, :nested_abilities
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[keywords abilities], errors, path)
+          keywords = StationSymbol.build_keywords(params, errors, path)
+          abilities = StationSymbol.build_abilities(params, errors, path)
+          abilities.each_with_index do |ability, i|
+            errors << "#{path}.abilities[#{i}]: max speed abilities can't be nested" if ability.kind == :max_speed
+          end
+          errors << "#{path}: needs keywords or abilities" if keywords.empty? && abilities.empty?
+          new(keywords, abilities)
+        end
+
+        def initialize(keywords, abilities)
+          super()
+          @keywords = keywords.freeze
+          @nested_abilities = abilities.freeze
+          freeze
+        end
+
+        def kind = :max_speed
+        def power = nil
+        def mana_ability? = false
+        def allowed_types = nil
+        def try_effects = []
+        def to_s = "Max speed — #{(keywords.map(&:to_s) + nested_abilities.map(&:to_s)).join("; ")}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Costs
+      # "Tap another untapped creature you control" as a cost (CR 702.184a, 602.2b). The player chooses
+      # the creature while activating (a `choose_cost` decision). Summoning sickness doesn't matter:
+      # CR 302.6 restricts only a creature's own {T} abilities.
+      class TapAnotherCreature < Primitive
+        primitive :cost, :tap_another_creature,
+                  description: "Tap another untapped creature you control, chosen while activating. A creature " \
+                               "that came under your control this turn can be tapped this way.",
+                  rules: %w[702.184a 601.2h 602.2b 302.6],
+                  example: "tap_another_creature"
+
+        INSTANCE = new.freeze
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, [], errors, path)
+          INSTANCE
+        end
+
+        def mana? = false
+        def payable?(engine, object) = !choice_candidates(engine, object).empty?
+        # Paid when chosen (Engine#choose_cost!).
+        def pay!(_engine, _object) = nil
+        def to_s = "Tap another untapped creature you control"
+
+        def choices_needed = 1
+        def choice_options(engine, object, _chosen) = choice_candidates(engine, object).map { { object: it } }
+
+        def choose!(engine, option)
+          creature = engine.object(option[:object])
+          engine.tap!(creature)
+          { "object" => creature.id, "power" => Abilities::TappingPower.of(engine, creature, :station), "tapped" => true }
+        end
+
+        def choice_candidates(engine, object)
+          engine.state.battlefield.select do |id|
+            other = engine.object(id)
+            id != object.id && other.controller == object.controller && !other.tapped && engine.chars(other).creature?
+          end
+        end
+      end
+    end
+
+    module Effects
+      # The effect of a station ability (CR 702.184a): put charge counters on its source equal to the
+      # power of the creature tapped to pay its cost. That's the creature's current power, or, if it has
+      # left the battlefield, its power when it was tapped; an ability may make it use its toughness (CR 702.184c,
+      # Abilities::TappingPower).
+      class StationCharge < Effect
+        def self.keys = %w[to]
+
+        def apply(engine, ctx)
+          paid = engine.object(ctx.object).paid&.first or return
+          creature = paid["object"]
+          on = engine.state.battlefield.include?(creature)
+          n = on ? Abilities::TappingPower.of(engine, engine.object(creature), :station) : paid["power"]
+          objects(engine, ctx).each { engine.add_counters!(engine.object(it), "charge", n) }
+        end
+
+        def to_s = "put charge counters equal to the tapped creature's power on this"
+      end
+    end
+
+    module Keywords
+      # Station (CR 702.184a): "Tap another untapped creature you control: Put a
+      # number of charge counters on this permanent equal to the tapped creature's power. Activate only as
+      # a sorcery." A station card has it at all times, whatever its charge counters (CR 722.4).
+      class Station < Primitive
+        primitive :keyword, :station,
+                  description: "An activated ability: tap another untapped creature you control to put charge " \
+                               "counters equal to its power on this permanent. Sorcery speed. Pair with " \
+                               "`station_symbol` abilities for what the counters unlock.",
+                  rules: %w[702.184a 722.4],
+                  example: { "keywords" => ["station"] }
+
+        def self.intrinsic_abilities
+          @intrinsic_abilities ||= [
+            Abilities::ActivatedAbility.new(
+              sorcery: true, targets: [].freeze, costs: [Costs::TapAnotherCreature::INSTANCE].freeze,
+              effects: [Effects::StationCharge.new(to: Selector.new(:self), params: {}, errors: [], path: "station")].freeze
+            )
+          ].freeze
+        end
+      end
+    end
+
+    module Abilities
+      # A station symbol "{N+}" (CR 722.2): as long as this permanent has N or more charge counters, it
+      # has the listed keywords and abilities and, with a power/toughness box, is a creature with that base
+      # power and toughness in addition to its other types (CR 722.2a-b). A station card has no power or
+      # toughness off the battlefield (CR 722.2c), so P/T goes here, not on the card.
+      class StationSymbol < Primitive
+        primitive :ability, :station_symbol,
+                  description: "While this permanent has at least `at` charge counters it has `keywords` and " \
+                               "`abilities`; with `power`/`toughness` it is also a creature with that base power " \
+                               "and toughness (layers 4 and 7b).",
+                  rules: %w[722.2a 722.2b 722.2c 613.1d 613.4b],
+                  params: { "at" => "integer >= 1 (the N of {N+})", "power" => "integer", "toughness" => "integer",
+                            "keywords" => "list of keywords", "abilities" => "list of abilities" },
+                  example: { "station_symbol" => { "at" => 6, "power" => 3, "toughness" => 4, "keywords" => ["flying"] } }
+
+        attr_reader :threshold, :power, :toughness, :keywords, :nested_abilities
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[at power toughness keywords abilities], errors, path)
+          threshold = Mechanics.integer_param(params, :at, errors, path, min: 1)
+          stats = %w[power toughness].map { Mechanics.fetch_param(params, it) }
+          if stats.compact.size == 1 || !stats.compact.all?(Integer)
+            errors << "#{path}: power and toughness must both be integers, or both be left out"
+            stats = [nil, nil]
+          end
+          keywords = build_keywords(params, errors, path)
+          abilities = build_abilities(params, errors, path)
+          errors << "#{path}: needs power/toughness, keywords or abilities" if stats.compact.empty? && keywords.empty? && abilities.empty?
+          new(threshold, *stats, keywords, abilities)
+        end
+
+        def self.build_keywords(params, errors, path)
+          list = Mechanics.list_param(params, :keywords, errors, path).map { it.to_s.downcase.tr(" -", "__") }
+          list.each { errors << "#{path}.keywords: unknown keyword #{it.inspect}" unless Enjine.registry.fetch(:keyword, it) }
+          list.map(&:to_sym)
+        end
+
+        def self.build_abilities(params, errors, path)
+          Mechanics.list_param(params, :abilities, errors, path).each_with_index.filter_map do |entry, i|
+            ability = Mechanics.build_entry(:ability, entry, errors, "#{path}.abilities[#{i}]")
+            if ability&.kind == :station_symbol
+              errors << "#{path}.abilities[#{i}]: station symbols can't be nested"
+              next
+            end
+            ability
+          end
+        end
+
+        def initialize(threshold, power, toughness, keywords, abilities)
+          super()
+          @threshold = threshold
+          @power = power
+          @toughness = toughness
+          @keywords = keywords.freeze
+          @nested_abilities = abilities.freeze
+          freeze
+        end
+
+        def kind = :station_symbol
+        def mana_ability? = false
+        def allowed_types = nil
+        def try_effects = []
+
+        def to_s
+          bits = []
+          bits << "#{power}/#{toughness} creature" if power
+          bits.concat(keywords.map(&:to_s))
+          bits.concat(nested_abilities.map(&:to_s))
+          "#{threshold}+ | #{bits.join("; ")}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Keywords
+      # Storied (CR 702.195a): "Any time you control three or more permanents that are artifacts, Sagas, and/or
+      # legendary and you don't have an enduring story, you have an enduring story for the rest of the game."
+      # The engine checks it (Engine::Designations#tell_enduring_stories!); cards read the designation with
+      # the condition `{"designation": "enduring_story"}`.
+      class Storied < Primitive
+        primitive :keyword, :storied,
+                  description: "While you control this permanent, once you control three or more permanents that are " \
+                               "artifacts, Sagas and/or legendary, you have an enduring story for the rest of the game " \
+                               "(condition `{\"designation\": \"enduring_story\"}`).",
+                  rules: %w[702.195a 702.195b 702.195c], example: { "keywords" => ["storied"] }
+      end
+    end
+
+    class Condition
+      # "If you have an enduring story" / "as long as you have an enduring story": the controller has a player
+      # designation (Engine::Designations; CR 702.195b).
+      class Designation
+        def self.build(data, errors, path)
+          Mechanics.check_keys(data, %w[designation], errors, path)
+          value = data["designation"]
+          known = Engine::Designations::NAMES
+          errors << "#{path}.designation: must be one of #{known.join(", ")}" unless known.include?(value)
+          new(value)
+        end
+
+        def initialize(designation)
+          @designation = designation
+          freeze
+        end
+
+        def true?(engine, ctx) = engine.designation?(ctx.controller, @designation)
+        def to_s = "you have #{@designation == "enduring_story" ? "an enduring story" : @designation.tr("_", " ")}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "../abilities/play_permissions"
+
+module Enjine
+  module Mechanics
+    module Triggers
+      # The number of spells cast this turn before the one whose cast is being looked at (its SpellCast is
+      # already in the turn's history, Engine::TurnHistory): a cast trigger's "that many" (storm, CR 702.40a).
+      def self.spells_before(engine)
+        engine.state.players.each_index.sum { engine.turn_log(it).fetch("spells", []).size } - 1
+      end
+    end
+
+    module Effects
+      # Cascade's effect (CR 702.85a): exile cards from the top of your library until you exile a nonland card
+      # whose mana value is less than this spell's; you may cast it without paying its mana cost; then all
+      # exiled cards not cast go on the bottom of your library in a random order. Discover's steps with
+      # another limit and miss.
+      class Cascade < Discover
+        def self.build_for_keyword = new(to: Selector.new(:you), params: { "amount" => 0 }, errors: [], path: "cascade")
+
+        def to_s = "cascade"
+
+        private
+
+        # Less than this spell's mana value (X included on the stack, CR 202.3e); if the spell has left the
+        # stack, its card's mana value.
+        def limit(engine, ctx)
+          spell = engine.state.objects[ctx.source]
+          cost = spell ? engine.chars(spell).mana_cost&.with_x(spell.x.to_i) : triggering_cost(engine, ctx)
+          cost ? cost.mana_value - 1 : -1
+        end
+
+        def triggering_cost(engine, ctx)
+          card = Selector.memory(engine, ctx).dig("triggering", "card")
+          card && engine.catalog.fetch(card).mana_cost
+        end
+
+        def miss_type = "decline"
+        def prompt = "Cascade: you may cast it without paying its mana cost"
+        def miss!(_engine, _hit) = nil
+      end
+    end
+
+    module Keywords
+      # Storm (CR 702.40a): "When you cast this spell, copy it for each other spell that was cast before it this
+      # turn. If the spell has any targets, you may choose new targets for any of the copies." Each instance
+      # triggers separately (CR 702.40b).
+      class Storm < Primitive
+        primitive :keyword, :storm,
+                  description: "When you cast this spell, copy it for each other spell cast before it this turn; you " \
+                               "may choose new targets for the copies.",
+                  rules: %w[702.40a 702.40b 707.10], example: { "keywords" => ["storm"] }
+
+        ABILITY = { "triggered" => { "when" => { "cast" => { "self" => true } },
+                                     "effects" => [{ "copy_spell" => { "of" => "self", "amount" => { "triggering" => "amount" },
+                                                                       "new_targets" => true } }] } }.freeze
+
+        def self.intrinsic_abilities = @intrinsic_abilities ||= [Keywords.ability_from_data(ABILITY, "storm")].freeze
+      end
+
+      # Cascade (CR 702.85a): "When you cast this spell, exile cards from the top of your library until you exile
+      # a nonland card whose mana value is less than this spell's mana value. You may cast that card without
+      # paying its mana cost if the resulting spell's mana value is less than this spell's mana value. Then put
+      # all cards exiled this way that weren't cast on the bottom of your library in a random order." Each
+      # instance triggers separately (CR 702.85c).
+      class Cascade < Primitive
+        primitive :keyword, :cascade,
+                  description: "When you cast this spell, exile cards from the top of your library until you exile a " \
+                               "nonland card with lesser mana value. You may cast it without paying its mana cost. " \
+                               "Then the exiled cards not cast go on the bottom of your library in a random order.",
+                  rules: %w[702.85a 702.85c 608.2g], example: { "keywords" => ["cascade"] }
+
+        def self.intrinsic_abilities
+          @intrinsic_abilities ||= begin
+            trigger = Keywords.ability_from_data({ "triggered" => { "when" => { "cast" => { "self" => true } },
+                                                                    "effects" => [] } }, "cascade").trigger
+            [Abilities::TriggeredAbility.new(trigger: trigger, targets: [].freeze,
+                                             effects: [Effects::Cascade.build_for_keyword].freeze)].freeze
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Keywords
+      # Sunburst (CR 702.44): enters with a counter for each color of mana spent to cast it.
+      class Sunburst < Primitive
+        primitive :keyword, :sunburst,
+                  description: "As this permanent enters from the stack as a resolving spell, it gets a +1/+1 counter " \
+                               "(a creature) or a charge counter (otherwise) for each color of mana spent to cast it.",
+                  rules: %w[702.44a 702.44b], example: { "keywords" => ["sunburst"] }
+
+        COLORS = Mana::COLORS.map(&:to_s).freeze
+
+        # The counters a resolving spell enters with (CR 702.44a); type-changing effects are ignored,
+        # so the printed card types decide the kind. CR 702.44b: only colored mana counts.
+        def self.entering_counters(engine, spell)
+          printed = engine.chars(spell)
+          return {} unless printed.keyword?(:sunburst)
+
+          colors = (spell.mana_spent || []).uniq & COLORS
+          return {} if colors.empty?
+
+          { printed.creature? ? "+1/+1" : "charge" => colors.size }
+        end
+      end
+    end
+  end
+end