enjine 0.1.0

data/lib/enjine/mechanics/abilities/restrictions.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Abilities
+      # Base for restriction abilities a permanent has on itself (CR 509.1b, 115.4): no stack, no effects.
+      class Restriction < Primitive
+        def mana_ability? = false
+        def allowed_types = nil
+        def try_effects = []
+      end
+
+      # "This creature can't be blocked by creatures with power 2 or less" / "... by artifact creatures".
+      class CantBeBlockedBy < Restriction
+        primitive :ability, :cant_be_blocked_by,
+                  description: "This creature can't be blocked by creatures matching `filter` (checked as blockers " \
+                               "are declared, with their current characteristics).",
+                  rules: %w[509.1b 509.1a],
+                  params: { "filter" => "a creature filter, e.g. {\"creature\": {\"power\": {\"at_most\": 2}}}" },
+                  example: { "cant_be_blocked_by" => { "filter" => { "creature" => { "power" => { "at_most" => 2 } } } } }
+
+        attr_reader :filter
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[filter], errors, path)
+          raw = Mechanics.fetch_param(params, :filter)
+          errors << "#{path}.filter: required" if raw.nil?
+          filter = raw && Mechanics.build_entry(:filter, raw, errors, "#{path}.filter")
+          new(filter)
+        end
+
+        def initialize(filter)
+          super()
+          @filter = filter
+          freeze
+        end
+
+        def kind = :cant_be_blocked_by
+        def allowed_types = [:creature]
+        def to_s = "can't be blocked by #{filter.is_a?(Class) ? filter.primitive_name : filter}"
+
+        # Whether `blocker` may not block this creature (controller-relative filter keys use the blocker's).
+        def forbids?(engine, blocker) = filter.match?(engine, blocker, engine.object(blocker).controller)
+      end
+
+      # "This token can block only creatures with flying" / "This creature can't block non-Spirit creatures".
+      class CanBlockOnly < Restriction
+        primitive :ability, :can_block_only,
+                  description: "This creature can block only attacking creatures matching `filter` (checked as " \
+                               "blockers are declared, with their current characteristics; controller-relative " \
+                               "filter keys are seen from this creature's controller).",
+                  rules: %w[509.1b 509.1a],
+                  params: { "filter" => "a creature filter, e.g. {\"creature\": {\"keywords\": [\"flying\"]}}" },
+                  example: { "can_block_only" => { "filter" => { "creature" => { "keywords" => ["flying"] } } } }
+
+        attr_reader :filter
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[filter], errors, path)
+          raw = Mechanics.fetch_param(params, :filter)
+          errors << "#{path}.filter: required" if raw.nil?
+          new(raw && Mechanics.build_entry(:filter, raw, errors, "#{path}.filter"))
+        end
+
+        def initialize(filter)
+          super()
+          @filter = filter
+          freeze
+        end
+
+        def kind = :can_block_only
+        def allowed_types = [:creature]
+        def to_s = "can block only #{filter.is_a?(Class) ? filter.primitive_name : filter}"
+
+        # Whether this creature (`blocker`) may block `attacker`.
+        def allows?(engine, blocker, attacker) = filter.match?(engine, attacker, engine.object(blocker).controller)
+      end
+
+      # "This creature can't be the target of abilities from artifact sources your opponents control."
+      class CantBeTargetedBy < Restriction
+        primitive :ability, :cant_be_targeted_by,
+                  description: "This permanent can't be the target of abilities its controller's opponents control " \
+                               "whose source matches `abilities_from` (a card spec, e.g. {\"types\": [\"artifact\"]}).",
+                  rules: %w[115.4 113.7 702.11d],
+                  params: { "abilities_from" => "card spec of the ability's source" },
+                  example: { "cant_be_targeted_by" => { "abilities_from" => { "types" => ["artifact"] } } }
+
+        attr_reader :spec
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[abilities_from], errors, path)
+          raw = Mechanics.fetch_param(params, :abilities_from)
+          errors << "#{path}.abilities_from: required" if raw.nil?
+          new(CardSpec.build(raw, errors, "#{path}.abilities_from"))
+        end
+
+        def initialize(spec)
+          super()
+          @spec = spec
+          freeze
+        end
+
+        def kind = :cant_be_targeted_by
+        def to_s = "can't be the target of abilities from #{spec.to_s.delete_suffix(" card")} sources opponents control"
+
+        # Whether an ability whose source is `source` (a card object) may not target this permanent.
+        def forbids?(engine, source) = spec.match?(engine, source)
+      end
+
+      # "You can't cast this spell unless there are seven or more cards in your graveyard" / "You can't cast this
+      # spell during your first, second, or third turns of the game" (CR 601.3): the card can be cast, from any
+      # zone and by any permission, only while the condition holds for the player who would cast it.
+      class CastRestriction < Restriction
+        primitive :ability, :cast_restriction,
+                  description: "This card can be cast only while `only_if` (a condition, checked for the player who " \
+                               "would cast it) holds, whatever lets them cast it.",
+                  rules: %w[601.3 101.2],
+                  params: { "only_if" => "condition" },
+                  example: { "cast_restriction" => { "only_if" => { "amount" => { "graveyard_size" => "you" }, "at_least" => 7 } } }
+
+        attr_reader :condition
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[only_if], errors, path)
+          raw = Mechanics.fetch_param(params, :only_if)
+          errors << "#{path}.only_if: required" if raw.nil?
+          new(raw && Condition.build(raw, errors, "#{path}.only_if"))
+        end
+
+        def initialize(condition)
+          super()
+          @condition = condition
+          freeze
+        end
+
+        def kind = :cast_restriction
+        def to_s = "You can't cast this spell unless #{condition}."
+
+        # Whether player `index` may begin to cast `obj` now.
+        def allows?(engine, index, obj) = condition.nil? || condition.true?(engine, EffectContext.new(index, obj.id, obj.id, nil, []))
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/abilities/spell_keywords.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Abilities
+      # "Instant and sorcery spells you cast from your hand have cascade" (CR 604.1, 611.3a): a static ability of a
+      # permanent giving keywords to the spells its controller controls on the stack that match `spells` (and were
+      # cast `from` / `not_from` a zone). See Engine::SpellGrants.
+      class SpellKeywords < Primitive
+        primitive :ability, :spell_keywords,
+                  description: "Spells you control on the stack matching `spells` (a spell filter; default every " \
+                               "spell), cast `from` / `not_from` a zone if given, have the `keywords` (e.g. cascade, " \
+                               "which then triggers as such a spell is cast).",
+                  rules: %w[604.1 611.3a 702.85a],
+                  params: { "spells" => "spell filter", "from" => "zone", "not_from" => "zone",
+                            "keywords" => "list of keywords" },
+                  example: { "spell_keywords" => { "spells" => { "spell" => { "any_of" => %w[instant sorcery] } },
+                                                   "from" => "hand", "keywords" => ["cascade"] } }
+
+        attr_reader :keywords
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[spells from not_from keywords], errors, path)
+          filter = params["spells"] && Mechanics.build_entry(:filter, params["spells"], errors, "#{path}.spells")
+          keywords = Array(params["keywords"]).map(&:to_s)
+          errors << "#{path}.keywords: needs at least one keyword" if keywords.empty?
+          keywords.each { errors << "#{path}.keywords: unknown keyword #{it.inspect}" unless Enjine.registry.fetch(:keyword, it) }
+          new(filter, CastFrom.build(params, errors, path), keywords.map(&:to_sym).freeze)
+        end
+
+        def initialize(filter, zones, keywords)
+          super()
+          @filter = filter
+          @zones = zones
+          @keywords = keywords
+          freeze
+        end
+
+        def kind = :spell_keywords
+        def mana_ability? = false
+        def allowed_types = nil
+        def try_effects = []
+
+        # `spell`: a spell on the stack controlled by the controller of `source`.
+        def applies_to?(engine, spell, source)
+          return false if spell.ability? || !@zones.match?(engine.cast_origin(spell))
+
+          @filter.nil? || @filter.match_for?(engine, spell.id, source.controller, source.id)
+        end
+
+        def to_s = "#{@filter || "Spells"} you cast#{@zones} have #{keywords.join(", ")}"
+      end
+    end
+  end
+end