enjine 0.1.0

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

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Triggers
+      # "When ~ enters" / "Whenever a creature you control enters" (landfall: lands you control).
+      # `untapped: true` is "when this land enters untapped": the status it entered with (CR 614.12).
+      # `from`: only a permanent that entered from that zone ("enters from exile", CR 603.6a).
+      class Enters < Trigger
+        FROM = %w[hand graveyard exile library stack outside].freeze
+
+        primitive :trigger, :enters,
+                  description: "The subject enters the battlefield. `untapped: true`: only if it entered untapped. " \
+                               "`from`: only if it entered from that zone (\"enters from exile\").",
+                  rules: %w[603.6a 603.2 614.12],
+                  params: { "subject" => "\"self\" (default) or {\"each\": filter, \"controller\": you|opponent|any, \"other\": true}",
+                            "untapped" => "true | false", "from" => FROM.join(" | ") },
+                  example: { "enters" => { "subject" => { "each" => "land", "controller" => "you" } } }
+
+        def self.keys = %w[subject untapped from]
+        def event_class = Events::ZoneChanged
+
+        def setup(params, errors, path)
+          @untapped = params.fetch("untapped", false)
+          errors << "#{path}.untapped: must be true or false" unless [true, false].include?(@untapped)
+          @from = params["from"]
+          errors << "#{path}.from: must be one of #{FROM.join(", ")}" unless @from.nil? || FROM.include?(@from)
+        end
+
+        def match?(engine, event, source)
+          return false unless event.to == "battlefield" && (@from.nil? || event.from == @from)
+
+          obj = engine.state.objects[event.new_id] or return false
+          return false if @untapped && obj.tapped
+
+          @subject.match?(engine, event.new_id, obj.controller, event.card, source, types: engine.chars(obj).types)
+        end
+
+        def to_s = "When #{@subject} enters#{" untapped" if @untapped}#{" from #{@from}" if @from}"
+      end
+
+      # "Whenever you play a land" (CR 305.1): a player plays a land, from their hand or, when an effect allows it,
+      # from another zone (`from` / `not_from`: "from exile", "from anywhere other than your hand"). Putting a land
+      # onto the battlefield with an effect isn't playing it.
+      class PlaysLand < PlayerTrigger
+        primitive :trigger, :plays_land,
+                  description: "A player (`controller`: you (default) | opponent | any) plays a land. `from` / " \
+                               "`not_from`: only a land played from (not from) that zone: hand | graveyard | exile | " \
+                               "library | outside. Lands put onto the battlefield by effects aren't played.",
+                  rules: %w[305.1 603.2 601.2a],
+                  params: { "controller" => PLAYERS.join(" | "), "from" => "zone", "not_from" => "zone" },
+                  example: { "plays_land" => { "not_from" => "hand" } }
+
+        def self.keys = %w[controller from not_from]
+        def event_class = Events::ZoneChanged
+
+        def setup(params, errors, path)
+          super
+          @zones = CastFrom.build(params, errors, path)
+        end
+
+        def match?(engine, event, source)
+          return false unless event.reason == "play_land" && event.to == "battlefield" && @zones.match?(event.from)
+
+          player = engine.state.objects[event.new_id]&.controller || engine.names.index(event.owner)
+          player_ok?(engine, engine.name(player), source)
+        end
+
+        def to_s = "Whenever #{who} play#{"s" unless @controller == "you"} a land#{@zones}"
+      end
+
+      # "When ~ dies" / "Whenever another creature you control dies".
+      class Dies < Trigger
+        primitive :trigger, :dies,
+                  description: "The subject is put into a graveyard from the battlefield. Looks back in time (CR 603.10a).",
+                  rules: %w[603.6c 603.10a 700.4],
+                  params: { "subject" => "\"self\" (default) or {\"each\": filter, ...}" },
+                  example: { "dies" => { "subject" => "self" } }
+
+        def event_class = Events::ZoneChanged
+        def leaves_battlefield? = true
+
+        def match?(engine, event, source)
+          return false unless event.from == "battlefield" && event.to == "graveyard"
+
+          lki = engine.last_known(event.old_id) or return false
+          @subject.match?(engine, event.old_id, lki["controller"], event.card, source, types: lki["types"])
+        end
+
+        def to_s = "When #{@subject} dies"
+      end
+
+      # "When ~ leaves the battlefield" / "Whenever another creature you control leaves the battlefield"
+      # (CR 603.6c): a permanent moves from the battlefield to any other zone (`to`: only that zone). It
+      # looks back in time (CR 603.10a): the permanent is matched as it last existed, and its own ability
+      # triggers although it has left.
+      class LeavesBattlefield < Trigger
+        ZONES = %w[graveyard exile hand library].freeze
+
+        primitive :trigger, :leaves_battlefield,
+                  description: "The subject leaves the battlefield (for any zone, or only `to` that zone). Looks back " \
+                               "in time: the permanent is matched as it last existed (types, controller, counters).",
+                  rules: %w[603.6c 603.10a 400.7],
+                  params: { "subject" => "\"self\" (default) or {\"each\": filter, \"controller\": ..., \"other\": true}",
+                            "to" => ZONES.join(" | ") },
+                  example: { "leaves_battlefield" => { "subject" => { "each" => "creature", "controller" => "you",
+                                                                      "other" => true } } }
+
+        def self.keys = %w[subject to]
+        def event_class = Events::ZoneChanged
+        def leaves_battlefield? = true
+
+        def setup(params, errors, path)
+          @to = params["to"]
+          errors << "#{path}.to: must be one of #{ZONES.join(", ")}" unless @to.nil? || ZONES.include?(@to)
+        end
+
+        def match?(engine, event, source)
+          return false unless event.from == "battlefield" && (@to.nil? || event.to == @to)
+
+          lki = engine.last_known(event.old_id) or return false
+          @subject.match?(engine, event.old_id, lki["controller"], event.card, source, types: lki["types"])
+        end
+
+        def to_s
+          return "When #{@subject} leaves the battlefield" unless @to
+
+          "When #{@subject} is put into #{"a " unless @to == "exile"}#{@to} from the battlefield"
+        end
+      end
+
+      # "Whenever you sacrifice another permanent" / "a Food" (CR 701.21a): only its controller can sacrifice
+      # a permanent, so the subject's `controller` is who sacrificed it. Looks back in time (CR 603.10a).
+      class Sacrifices < Trigger
+        include Batched
+
+        primitive :trigger, :sacrifices,
+                  description: "The subject is sacrificed (`controller` of the subject: who sacrificed it). Looks back " \
+                               "in time, like leaves_battlefield. `batched: true`: \"one or more\", once per event batch.",
+                  rules: %w[701.21a 603.10a 603.2c],
+                  params: { "subject" => "\"self\" (default) or {\"each\": filter, \"controller\": you, \"other\": true}",
+                            "batched" => "true | false" },
+                  example: { "sacrifices" => { "subject" => { "each" => "artifact", "controller" => "you" } } }
+
+        def self.keys = %w[subject batched]
+        def event_class = Events::ZoneChanged
+        def leaves_battlefield? = true
+        def setup(params, errors, path) = setup_batched(params, errors, path)
+
+        def match?(engine, event, source)
+          return false unless event.from == "battlefield" && event.reason == "sacrifice"
+
+          lki = engine.last_known(event.old_id) or return false
+          @subject.match?(engine, event.old_id, lki["controller"], event.card, source, types: lki["types"])
+        end
+
+        def to_s = "Whenever #{@subject} is sacrificed"
+      end
+
+      # "Whenever one or more creature cards are put into your graveyard from anywhere" / "cards are put into
+      # exile from graveyards and/or the battlefield". `controller`: whose graveyard or exile, i.e. the card's
+      # owner. CR 603.6c: a "from anywhere" trigger is never a leaves-the-battlefield ability.
+      class PutInto < PlayerTrigger
+        include Batched
+        include CardMatch
+
+        ZONES = %w[graveyard exile].freeze
+        FROM = %w[battlefield graveyard hand library stack exile].freeze
+
+        primitive :trigger, :put_into,
+                  description: "A card is put into `zone` (graveyard | exile) from anywhere, or only `from` the listed " \
+                               "zones. `controller`: the card's owner (you (default) | opponent | any); optional `card` " \
+                               "filter on the card. `batched: true`: \"one or more cards\", once per event batch. With " \
+                               "\"battlefield\" among `from` it looks back in time like leaves_battlefield.",
+                  rules: %w[603.6c 603.2c 400.3],
+                  params: { "zone" => ZONES.join(" | "), "from" => "list of #{FROM.join(", ")} (default: anywhere)",
+                            "controller" => PLAYERS.join(" | "), "card" => "card filter", "batched" => "true | false" },
+                  example: { "put_into" => { "zone" => "graveyard", "card" => "creature", "batched" => true } }
+
+        def self.keys = %w[zone from controller card batched]
+        def event_class = Events::ZoneChanged
+        # CR 603.6c: "put into a graveyard from the battlefield" is a leaves-the-battlefield ability; "from anywhere"
+        # never is.
+        def leaves_battlefield? = @from&.include?("battlefield") || false
+
+        def setup(params, errors, path)
+          super
+          setup_batched(params, errors, path)
+          setup_card(params, errors, path)
+          @zone = params["zone"]
+          errors << "#{path}.zone: must be one of #{ZONES.join(", ")}" unless ZONES.include?(@zone)
+          @from = params["from"]
+          return if @from.nil? || (@from.is_a?(Array) && !@from.empty? && (@from - FROM).empty?)
+
+          errors << "#{path}.from: must be a list of #{FROM.join(", ")}"
+        end
+
+        def match?(engine, event, source)
+          event.to == @zone && (@from.nil? || @from.include?(event.from)) && player_ok?(engine, event.owner, source) &&
+            card_ok?(engine, event.card)
+        end
+
+        def to_s
+          into = @zone == "exile" ? "exile" : "#{{ "you" => "your", "opponent" => "an opponent's" }.fetch(@controller, "a")} graveyard"
+          from = @from ? " from #{@from.join(" or ")}" : " from anywhere"
+          "Whenever #{@batched ? "one or more #{card_words}s are" : "a #{card_words} is"} put into #{into}#{from}"
+        end
+      end
+
+      # "Whenever a card leaves your graveyard" / "whenever one or more cards leave your graveyard" (`batched`).
+      # Looks back in time (CR 603.10a): the card is matched as it was in the graveyard.
+      class LeavesGraveyard < PlayerTrigger
+        primitive :trigger, :leaves_graveyard,
+                  description: "A card leaves a graveyard (whose: `controller` you (default) | opponent | any). Optional " \
+                               "`card` filter on its card types. `batched: true` is \"one or more cards leave\": once per " \
+                               "event that moves cards (one effect, cost or action), however many cards.",
+                  rules: %w[603.10a 603.2c 404.1],
+                  params: { "controller" => PLAYERS.join(" | "), "card" => "card type filter, e.g. \"creature\"",
+                            "batched" => "true | false" },
+                  example: { "leaves_graveyard" => { "controller" => "you", "batched" => true } }
+
+        def self.keys = %w[controller card batched]
+        def event_class = Events::ZoneChanged
+        def batched? = @batched
+
+        def setup(params, errors, path)
+          super
+          @batched = params.fetch("batched", false)
+          errors << "#{path}.batched: must be true or false" unless [true, false].include?(@batched)
+          @card = params["card"] && Mechanics.build_entry(:filter, params["card"], errors, "#{path}.card")
+        end
+
+        def match?(engine, event, source)
+          return false unless event.from == "graveyard" && player_ok?(engine, event.owner, source)
+          return true unless @card
+
+          defn = engine.catalog.fetch(event.card)
+          @card.matches_facts?(Filters::Facts.new(chars: defn.printed_characteristics, counters: {}, token: defn.token?))
+        end
+
+        def to_s
+          what = @card ? Triggers.filter_words(@card) : "card"
+          whose = { "you" => "your", "opponent" => "an opponent's" }.fetch(@controller, "a")
+          "Whenever #{@batched ? "one or more #{what}s leave" : "a #{what} leaves"} #{whose} graveyard"
+        end
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/types/kindred.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Types
+      # Kindred (CR 308). A kindred card always has another card type, and is cast and resolves by that
+      # type's rules (CR 308.1): a "Kindred Instant" is an instant. Its subtypes are creature types
+      # (CR 308.2, 205.3m), so "Goblin spells" and "the number of creature types" see them.
+      class Kindred < Primitive
+        primitive :type, :kindred,
+                  description: "A card type that goes with another one (\"Kindred Sorcery — Goblin\"): the card is " \
+                               "cast and resolves as its other type, and its subtypes are creature types.",
+                  rules: %w[308.1 308.2 205.3m],
+                  example: { "name" => "Example Goblin Gambit", "mana_cost" => "{R}", "types" => %w[kindred sorcery],
+                             "subtypes" => ["goblin"],
+                             "abilities" => [{ "spell" => { "targets" => ["any_target"],
+                                                            "effects" => [{ "deal_damage" => { "amount" => 1,
+                                                                                               "to" => { "target" => 0 } } }] } }] }
+
+        def self.permanent? = false
+        def self.instant_speed? = false
+
+        # CR 308.1: each kindred card has another card type.
+        def self.validate(card, errors)
+          errors << "types: a kindred card needs another card type (CR 308.1)" if (Array(card["types"]).map(&:to_s) - ["kindred"]).empty?
+        end
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/types/land.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Types
+      # Land (CR 305). Played as a special action, never cast; one per turn.
+      class Land < Primitive
+        primitive :type, :land,
+                  description: "A permanent played with the special action \"play a land\" (one per turn, " \
+                               "main phase, empty stack). It has no mana cost.",
+                  rules: %w[305.1 305.2 305.3 202.1a],
+                  example: { "name" => "Forest", "types" => ["land"], "supertypes" => ["basic"],
+                             "subtypes" => ["forest"] }
+
+        def self.permanent? = true
+        def self.instant_speed? = false
+
+        def self.validate(card, errors)
+          errors << "mana_cost: lands have no mana cost (CR 202.1a)" if card.key?("mana_cost")
+        end
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/types/permanent_types.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Types
+      # Shared rules of permanent card types that are cast (artifact, creature,
+      # enchantment, planeswalker): sorcery timing unless something grants flash (CR 307.1 analogues).
+      class PermanentType < Primitive
+        def self.permanent? = true
+        def self.instant_speed? = false
+        def self.validate(_card, _errors) = nil
+      end
+
+      # Creature (CR 302). Has power and toughness; can attack and block; summoning sickness (302.6).
+      class Creature < PermanentType
+        primitive :type, :creature,
+                  description: "A permanent with power and toughness that can attack and block. Cast at sorcery " \
+                               "speed. It can't attack or use {T} abilities unless controlled continuously since " \
+                               "its controller's most recent turn began (summoning sickness).",
+                  rules: %w[302.1 302.4 302.6 307.1],
+                  example: { "name" => "Grizzly Bears", "mana_cost" => "{1}{G}", "types" => ["creature"],
+                             "subtypes" => ["bear"], "power" => 2, "toughness" => 2 }
+
+        def self.validate(card, errors)
+          %w[power toughness].each { |k| errors << "#{k}: creatures need an integer #{k} (CR 302.4)" unless card.key?(k) }
+        end
+      end
+
+      # Artifact (CR 301).
+      class Artifact < PermanentType
+        primitive :type, :artifact, description: "A permanent cast at sorcery speed.", rules: %w[301.1],
+                                    example: { "name" => "Example Relic", "mana_cost" => "{2}", "types" => ["artifact"] }
+      end
+
+      # Enchantment (CR 303).
+      class Enchantment < PermanentType
+        primitive :type, :enchantment, description: "A permanent cast at sorcery speed.", rules: %w[303.1],
+                                       example: { "name" => "Example Aura", "mana_cost" => "{1}{W}",
+                                                  "types" => ["enchantment"] }
+      end
+
+      # Planeswalker (CR 306). Enters with loyalty counters; one loyalty ability per turn.
+      class Planeswalker < PermanentType
+        primitive :type, :planeswalker,
+                  description: "A permanent that enters with loyalty counters equal to its printed loyalty. " \
+                               "Its loyalty abilities can be activated at sorcery speed, one per turn. Damage dealt " \
+                               "to it removes loyalty counters; at 0 loyalty it is put into its owner's graveyard.",
+                  rules: %w[306.5b 306.8 120.3c 606.3 704.5i],
+                  example: { "name" => "Vessa, Rally Captain", "mana_cost" => "{2}{W}{W}", "types" => ["planeswalker"],
+                             "loyalty" => 3,
+                             "abilities" => [{ "loyalty" => { "cost" => 1, "effects" => [
+                               { "pump" => { "power" => 1, "toughness" => 1,
+                                             "to" => { "each" => "creature", "controller" => "you" } } }
+                             ] } }] }
+
+        def self.validate(card, errors)
+          errors << "loyalty: planeswalkers need an integer loyalty (CR 306.5b)" unless card["loyalty"].is_a?(Integer)
+        end
+
+        # CR 306.5b: a planeswalker enters with loyalty counters equal to its printed loyalty.
+        def self.entering(definition, enters)
+          enters["counters"]["loyalty"] = definition.loyalty if definition.loyalty
+        end
+      end
+    end
+  end
+end

data/lib/enjine/mechanics/types/spell_types.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Types
+      # Instants and sorceries: never permanents; they go to the graveyard on resolution (CR 608.2n).
+      class SpellType < Primitive
+        def self.permanent? = false
+        def self.validate(_card, _errors) = nil
+      end
+
+      # Instant (CR 304). Cast any time you have priority.
+      class Instant < SpellType
+        primitive :type, :instant,
+                  description: "A spell cast any time its controller has priority. Its spell ability resolves, " \
+                               "then it goes to the graveyard.",
+                  rules: %w[304.1 304.2 608.2n],
+                  example: { "name" => "Lightning Bolt", "mana_cost" => "{R}", "types" => ["instant"],
+                             "abilities" => [{ "spell" => { "targets" => ["any_target"],
+                                                            "effects" => [{ "deal_damage" => { "amount" => 3,
+                                                                                               "to" => { "target" => 0 } } }] } }] }
+
+        def self.instant_speed? = true
+      end
+
+      # Sorcery (CR 307). Main phase, empty stack, own turn.
+      class Sorcery < SpellType
+        primitive :type, :sorcery,
+                  description: "A spell cast only in its controller's main phase while the stack is empty.",
+                  rules: %w[307.1 307.2 608.2n],
+                  example: { "name" => "Divination", "mana_cost" => "{2}{U}", "types" => ["sorcery"],
+                             "abilities" => [{ "spell" => { "effects" => [{ "draw" => { "amount" => 2 } }] } }] }
+
+        def self.instant_speed? = false
+      end
+    end
+  end
+end