enjine 0.1.0

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Transform permanents (CR 701.27): turn each referenced double-faced permanent over (see
+      # Engine::Faces#transform!).
+      class Transform < Effect
+        primitive :effect, :transform,
+                  description: "Transform each referenced permanent (default: this one): turn it over so its other " \
+                               "face is up. It stays the same object, and effects on it keep applying. Nothing " \
+                               "happens to a permanent that isn't a double-faced card or token, or whose other face " \
+                               "is an instant or sorcery. An ability of the permanent transforms it only if it hasn't " \
+                               "transformed since the ability was put on the stack.",
+                  rules: %w[701.27a 701.27c 701.27d 701.27e 701.27g 712.15],
+                  params: { "to" => "selector (default \"self\")" },
+                  example: { "transform" => { "to" => "self" } }
+
+        def self.keys = %w[to if]
+        def self.default_to = "self"
+
+        def apply(engine, ctx)
+          objects(engine, ctx).each do |id|
+            obj = engine.object(id)
+            engine.transform!(obj) if engine.transform_still_allowed?(obj, ctx)
+          end
+        end
+      end
+
+      # The prepared designation (CR 723.3a-b).
+      class Prepare < Effect
+        primitive :effect, :prepare,
+                  description: "Each referenced permanent (default: this one) becomes prepared, if it has a prepare " \
+                               "spell and isn't prepared already: its controller creates a copy of the prepare spell " \
+                               "in exile and may cast that copy while the permanent stays prepared. Casting it " \
+                               "unprepares the permanent.",
+                  rules: %w[723.3a 723.3c],
+                  params: { "to" => "selector (default \"self\")" },
+                  example: { "prepare" => { "to" => "self" } }
+
+        def self.keys = %w[to if]
+        def self.default_to = "self"
+
+        def apply(engine, ctx) = objects(engine, ctx).each { engine.prepare!(engine.object(it)) }
+      end
+
+      # CR 723.3b: "becomes unprepared".
+      class Unprepare < Effect
+        primitive :effect, :unprepare,
+                  description: "Each referenced permanent (default: this one) loses the prepared designation; the " \
+                               "copy of its prepare spell in exile ceases to exist.",
+                  rules: %w[723.3b 723.3c],
+                  params: { "to" => "selector (default \"self\")" },
+                  example: { "unprepare" => { "to" => "self" } }
+
+        def self.keys = %w[to if]
+        def self.default_to = "self"
+
+        def apply(engine, ctx) = objects(engine, ctx).each { engine.unprepare!(engine.object(it)) }
+      end
+    end
+
+    module Abilities
+      # "This creature enters prepared." (CR 723.3a): a self-replacement effect on its own entering.
+      class EntersPrepared < Primitive
+        primitive :ability, :enters_prepared,
+                  description: "This permanent enters the battlefield prepared (it needs a prepare spell, see " \
+                               "`layout: \"prepare\"`).",
+                  rules: %w[723.3a 614.1c],
+                  example: "enters_prepared"
+
+        INSTANCE = new.freeze
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, [], errors, path)
+          INSTANCE
+        end
+
+        def kind = :enters_prepared
+        def mana_ability? = false
+        def allowed_types = nil
+        def to_s = "enters prepared"
+        def try_effects = []
+
+        def validate_definition(defn, errors, path)
+          errors << "#{path}: only a card with a prepare spell (layout \"prepare\") enters prepared" unless defn.layout == "prepare"
+        end
+
+        def modify_entering(enters) = enters["prepared"] = true
+      end
+    end
+
+    module Triggers
+      # "Whenever this creature transforms into [this face]" (CR 701.27f): a self trigger is an ability of the
+      # face it transformed into, so it triggers only on transforming into that face.
+      class Transforms < Trigger
+        primitive :trigger, :transforms,
+                  description: "The subject transforms. For the default subject (this permanent), the ability is on " \
+                               "the face that's up afterward, so it means \"whenever this transforms into [this face]\".",
+                  rules: %w[701.27f 603.2],
+                  params: { "subject" => "\"self\" (default) or {\"each\": filter, ...}" },
+                  example: { "transforms" => {} }
+
+        def event_class = Events::Transformed
+
+        def match?(engine, event, source)
+          obj = engine.state.objects[event.object] or return false
+          @subject.match?(engine, event.object, obj.controller, obj.card, source, types: engine.chars(obj).types)
+        end
+
+        def to_s = "whenever #{@subject} transforms"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Base for effects with a second selector besides `to` (`with` / `from`).
+      class PairEffect < Effect
+        def self.other_key = raise(NotImplementedError)
+        def self.keys = ["to", other_key, "if"]
+
+        attr_reader :other
+
+        def setup(params, errors, path)
+          key = self.class.other_key
+          raw = Mechanics.fetch_param(params, key)
+          @other = if raw.nil?
+                     (errors << "#{path}.#{key}: required") && nil
+                   else
+                     Selector.build(raw, errors, "#{path}.#{key}", targets_count: @targets_count, results_count: @results_count)
+                   end
+        end
+
+        def other_creatures(engine, ctx)
+          other.resolve(engine, ctx).select { engine.state.battlefield.include?(it) && engine.chars(it).creature? }
+        end
+
+        def creatures(engine, ctx) = objects(engine, ctx).select { engine.chars(it).creature? }
+      end
+
+      # "Target creature you control fights target creature an opponent controls." (CR 701.14)
+      class Fight < PairEffect
+        primitive :effect, :fight,
+                  description: "The creature referenced by `to` fights the one referenced by `with`: each deals " \
+                               "damage equal to its power to the other at the same time (not combat damage). If " \
+                               "either is gone, no longer a creature or an illegal target, neither deals damage. " \
+                               "{\"this_way\": n} naming it is the excess damage dealt to the `with` creature.",
+                  rules: %w[701.14a 701.14b 701.14c 701.14d 120.4a],
+                  params: { "to" => "selector (one creature)", "with" => "selector (one creature)" },
+                  example: { "fight" => { "to" => { "target" => 0 }, "with" => { "target" => 1 } } }
+
+        def self.other_key = "with"
+
+        def apply(engine, ctx)
+          one = refs(engine, ctx).first
+          other_one = other.resolve(engine, ctx).first
+          # Nothing happens unless both are creatures on the battlefield. The excess damage dealt to the
+          # `with` creature is what {"this_way": n} reads (CR 120.4a).
+          engine.record_amount!(engine.fight!(one, other_one))
+        end
+
+        def to_s = "#{to} fights #{other}"
+      end
+
+      # "Target creatures you control each deal damage equal to their power to target creature." ("bite")
+      class Bite < PairEffect
+        primitive :effect, :bite,
+                  description: "Each creature referenced by `from` deals damage equal to its power to each creature, " \
+                               "planeswalker or player referenced by `to` (one damage event per source; not combat " \
+                               "damage, and nothing is dealt back).",
+                  rules: %w[120.3 120.4 608.2b],
+                  params: { "from" => "selector (the creatures dealing damage)", "to" => "selector" },
+                  example: { "bite" => { "from" => { "target" => 0 }, "to" => { "target" => 1 } } }
+
+        def self.other_key = "from"
+
+        def apply(engine, ctx)
+          sources = other_creatures(engine, ctx)
+          powers = sources.to_h { [it, engine.power(engine.object(it))] } # determined before any is dealt
+          sources.each { |source| refs(engine, ctx).each { engine.deal_damage!(source, it, powers[source]) } }
+        end
+
+        def to_s = "#{other} each deal damage equal to their power → #{to}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "../abilities/turn_rules"
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Flipping coins (CR 705). With `count: "wins"` (default) the flipper calls each coin, heads or tails,
+      # and wins the flips whose result matches the call (CR 705.2); with `count: "heads"` the effect only
+      # cares how many coins come up heads and nobody wins or loses. The number counted is the effect's
+      # amount for later effects ({"this_way": n}): "if you win the flip, ..." is an `if` comparing it.
+      class FlipCoins < ChoiceEffect
+        COUNTS = %w[wins heads].freeze
+        CALLS = [{ "type" => "call", "call" => "heads" }, { "type" => "call", "call" => "tails" }].freeze
+
+        primitive :effect, :flip_coins,
+                  description: "You flip `amount` coins (default 1), each coming up heads or tails at random (the " \
+                               "game's random number generator). `count`: \"wins\" (default; you call each flip and " \
+                               "win it if the call matches) or \"heads\" (no one wins or loses). How many were " \
+                               "counted is this effect's amount: {\"this_way\": n} in later effects and conditions.",
+                  rules: %w[705.1 705.2 705.3 608.2c],
+                  params: { "amount" => "amount (default 1)", "count" => COUNTS.join(" | ") },
+                  example: { "flip_coins" => {} }
+
+        def self.keys = %w[amount count if]
+        def self.default_to = "you"
+
+        def initialize(to:, params:, errors:, path:, targets_count: 0, results_count: 0)
+          params = params.transform_keys(&:to_s)
+          params["amount"] = 1 unless params.key?("amount")
+          super
+        end
+
+        def setup(params, errors, path)
+          @count = Mechanics.fetch_param(params, :count) || "wins"
+          errors << "#{path}.count: must be one of #{COUNTS.join(", ")}" unless COUNTS.include?(@count)
+        end
+
+        def to_s = "flip #{amount == 1 ? "a coin" : "#{amount} coins"} (counting #{@count})"
+
+        # A call is asked before each flip (CR 705.2); the flips happen as they are called.
+        def run(engine, ctx, locals)
+          unless locals["left"]
+            return :done unless condition.nil? || condition.true?(engine, ctx)
+
+            locals["left"] = amount_for(engine, ctx)
+            locals["fixed"] = true if Abilities::FirstFlipsWin.applies?(engine, ctx.controller) # CR 705.3
+          end
+          calls = @count == "wins" && !locals["fixed"] # a flip with a stated result needs no call (CR 705.3)
+          while locals["left"].positive?
+            call = calls ? answers(locals).shift&.fetch("call") : nil
+            return ask(engine, locals, ctx.controller, "Call the coin flip", CALLS) if calls && call.nil?
+
+            flip!(engine, ctx, call, fixed: locals["fixed"])
+            locals["left"] -= 1
+          end
+          :done
+        end
+
+        private
+
+        # CR 705.3: a flip with a stated result (heads, and won) ignores the actual result.
+        def flip!(engine, ctx, call, fixed: false)
+          heads = fixed || engine.state.rng.rand(2).zero?
+          won = fixed ? @count == "wins" || nil : call && (call == "heads") == heads
+          call = "heads" if fixed && @count == "wins"
+          engine.emit Events::CoinFlipped.new(player: engine.name(ctx.controller), heads: heads, won: won)
+          engine.record_amount!(1) if call ? won : heads
+        end
+      end
+    end
+
+    module Abilities
+      # "The first time you flip one or more coins each turn, those coins come up heads and you win those flips"
+      # (CR 705.3): the flips of the first flip_coins effect its controller performs each turn have that result
+      # (no call is asked). A flip is remembered in the turn's history (Engine::TurnHistory "coin_flips").
+      class FirstFlipsWin < TurnRule
+        primitive :ability, :first_flips_win,
+                  description: "The first time each turn its controller flips one or more coins, those coins come up " \
+                               "heads and they win those flips.",
+                  rules: %w[705.3 604.1], example: "first_flips_win"
+
+        INSTANCE = new.freeze
+
+        def kind = :first_flips_win
+        def to_s = "The first time you flip one or more coins each turn, those coins come up heads and you win those flips"
+
+        def self.applies?(engine, index)
+          engine.turn_log(index).fetch("coin_flips", 0).zero? &&
+            engine.state.battlefield.any? do |id|
+              engine.object(id).controller == index && engine.chars(id).abilities.any? { it.ability.kind == :first_flips_win }
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # "Gain control of target permanent" / "... until end of turn" / "Target opponent gains control of
+      # target permanent you control" (CR 613.1b, 108.4, 506.4, 302.6).
+      class GainControl < Effect
+        DURATIONS = %w[permanent end_of_turn while_source_on_battlefield while_source_tapped while_you_control_source].freeze
+
+        primitive :effect, :gain_control,
+                  description: "The player referenced by `gains` (default you) gains control of each referenced " \
+                               "permanent: indefinitely (`duration: \"permanent\"`, default), until end of turn, or for " \
+                               "as long as this effect's source remains on the battlefield / tapped / under your control (it does " \
+                               "nothing if that is already over). " \
+                               "A permanent that changes control leaves combat and is newly under its controller's " \
+                               "control (it can't attack or {T} without haste).",
+                  rules: %w[613.1b 108.4 506.4 302.6 514.2 611.2b],
+                  params: { "to" => "selector (permanents)", "gains" => "selector (a player; default \"you\")",
+                            "duration" => DURATIONS.join(" | ") },
+                  example: { "gain_control" => { "to" => { "target" => 0 }, "duration" => "end_of_turn" } }
+
+        attr_reader :gains, :duration
+
+        def self.keys = %w[to gains duration if]
+
+        def setup(params, errors, path)
+          @gains = Selector.build(Mechanics.fetch_param(params, :gains) || "you", errors, "#{path}.gains",
+                                  targets_count: @targets_count, results_count: @results_count)
+          @duration = Mechanics.fetch_param(params, :duration) || "permanent"
+          errors << "#{path}.duration: must be one of #{DURATIONS.join(", ")}" unless DURATIONS.include?(@duration)
+        end
+
+        def apply(engine, ctx)
+          player = gains.resolve(engine, ctx).filter_map { Filters.player_index(engine, it) }.first or return
+          return unless engine.source_duration_holds?(duration, ctx.source, ctx.controller)
+
+          objects(engine, ctx).each do |id|
+            obj = engine.object(id)
+            next engine.gain_control!(obj, player) if duration == "permanent"
+
+            engine.gain_control_for!(obj, player, ctx, duration: duration,
+                                                       source: duration == "end_of_turn" ? nil : ctx.source)
+          end
+        end
+
+        def to_s = "#{gains} gains control#{" until end of turn" if duration == "end_of_turn"} → #{to}"
+      end
+
+      # "Exchange control of target artifact you control and target artifact an opponent controls" (CR 701.12a-b):
+      # if both permanents are still there and controlled by different players, each player gains control of
+      # the other one (indefinitely); otherwise nothing happens.
+      class ExchangeControl < Effect
+        primitive :effect, :exchange_control,
+                  description: "The permanent `to` references and the one `with` references exchange controllers. " \
+                               "If either is gone or both have the same controller, nothing happens.",
+                  rules: %w[701.12a 701.12b 613.1b],
+                  params: { "to" => "selector (a permanent)", "with" => "selector (a permanent)" },
+                  example: { "exchange_control" => { "to" => { "target" => 0 }, "with" => { "target" => 1 } } }
+
+        attr_reader :with
+
+        def self.keys = %w[to with if]
+
+        def setup(params, errors, path)
+          @with = Exchange.with(params, errors, path, @targets_count, @results_count)
+        end
+
+        def apply(engine, ctx)
+          first, second = [to, with].map { |sel| sel.resolve(engine, ctx).find { engine.state.battlefield.include?(it) } }
+          return if first.nil? || second.nil? || first == second
+
+          a = engine.object(first)
+          b = engine.object(second)
+          return if a.controller == b.controller
+
+          timestamp = engine.next_timestamp!
+          [[a, b.controller], [b, a.controller]].each { |obj, controller| engine.gain_control!(obj, controller, timestamp) }
+        end
+
+        def to_s = "exchange control of #{to} and #{with}"
+      end
+
+      # The `with` side of an exchange (CR 701.12a): a required selector.
+      module Exchange
+        def self.with(params, errors, path, targets_count, results_count)
+          raw = Mechanics.fetch_param(params, :with)
+          errors << "#{path}.with: required" if raw.nil?
+          Selector.build(raw || "you", errors, "#{path}.with", targets_count: targets_count, results_count: results_count)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Effects
+      # Base for effects that may end the game: once it's over, nothing else in the list happens.
+      class GameEndEffect < Effect
+        def self.keys = %w[to if]
+        def self.default_to = "you"
+
+        def run(engine, ctx, locals)
+          super
+          engine.state.over? ? :wait : :done # the game ended: resolution stops here
+        end
+      end
+
+      # "You win the game." (CR 104.2b)
+      class WinGame < GameEndEffect
+        primitive :effect, :win_game,
+                  description: "Each referenced player (default you) wins the game: every opponent loses it.",
+                  rules: %w[104.2a 104.2b 104.3f],
+                  params: { "to" => "selector" },
+                  example: "win_game"
+
+        def apply(engine, ctx) = players(engine, ctx).each { engine.win_game!(it) }
+        def to_s = "win the game → #{to}"
+      end
+
+      # "You lose the game." (CR 104.3e)
+      class LoseGame < GameEndEffect
+        primitive :effect, :lose_game,
+                  description: "Each referenced player (default you) loses the game.",
+                  rules: %w[104.3e 104.4a],
+                  params: { "to" => "selector" },
+                  example: "lose_game"
+
+        def apply(engine, ctx) = players(engine, ctx).each { engine.lose_game!(it) }
+        def to_s = "lose the game → #{to}"
+      end
+    end
+  end
+end