enjine 0.1.0

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Keywords
+      # Increment (CR 702.191a): "Whenever you cast a spell, if this permanent is a creature and the amount of
+      # mana spent to cast that spell is greater than this creature's power or this creature's toughness, put a
+      # +1/+1 counter on this creature." Each instance triggers separately (CR 702.191b).
+      class Increment < Primitive
+        primitive :keyword, :increment,
+                  description: "Whenever you cast a spell, if this is a creature and the mana spent to cast that " \
+                               "spell is greater than its power or its toughness, put a +1/+1 counter on it.",
+                  rules: %w[702.191a 702.191b 603.4], example: { "keywords" => ["increment"] }
+
+        # "greater than this creature's [stat]": mana spent - stat >= 1.
+        def self.exceeds(stat)
+          { "amount" => { "plus" => [{ "mana_spent" => { "of" => { "triggering" => "object" } } },
+                                     { "times" => [{ stat => "self" }, -1] }] }, "at_least" => 1 }
+        end
+
+        ABILITY = { "triggered" => {
+          "when" => { "cast" => { "controller" => "you" } },
+          "if" => { "all" => [{ "source" => "creature" }, { "any" => [exceeds("power"), exceeds("toughness")] }] },
+          "effects" => [{ "add_counters" => { "counter" => "+1/+1", "amount" => 1, "to" => "self" } }]
+        } }.freeze
+
+        def self.intrinsic_abilities = @intrinsic_abilities ||= [Keywords.ability_from_data(ABILITY, "increment")].freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Keywords
+      # Job select (CR 702.182a): "When this Equipment enters, create a 1/1 colorless Hero creature token,
+      # then attach this Equipment to it."
+      class JobSelect < Primitive
+        primitive :keyword, :job_select,
+                  description: "When this Equipment enters, create a 1/1 colorless Hero creature token, then " \
+                               "attach this Equipment to it.",
+                  rules: %w[702.182a], example: { "keywords" => ["job_select"] }
+
+        HERO = { "name" => "Hero", "types" => ["creature"], "subtypes" => ["hero"], "colors" => [], "power" => 1,
+                 "toughness" => 1 }.freeze
+        ABILITY = { "triggered" => { "when" => { "enters" => {} },
+                                     "effects" => [{ "create_token" => { "token" => HERO } },
+                                                   { "attach" => { "to" => { "result" => 0 } } }] } }.freeze
+
+        def self.intrinsic_abilities = @intrinsic_abilities ||= [Keywords.ability_from_data(ABILITY, "job_select")].freeze
+
+        # CR 702.182a: only an Equipment can be attached this way.
+        def self.validate(card, errors)
+          errors << "keywords: job_select is only for Equipment" unless Array(card["subtypes"]).include?("equipment")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Abilities
+      # Additional costs of a spell (CR 601.2b, 601.2f-h, 118.8): paid as the spell is cast, on top of its
+      # mana cost. Mana parts add to the total cost; other parts (sacrifice a creature) are chosen while
+      # casting and paid as it becomes cast.
+      class SpellCost < Primitive
+        attr_reader :costs
+
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[cost], errors, path)
+          costs = StackAbility.parse_costs(params, errors, path)
+          errors << "#{path}.cost: must be a non-empty list" if costs.empty? && errors.none? { it.start_with?("#{path}.cost") }
+          costs.each_with_index do |cost, i|
+            next if spell_cost?(cost)
+
+            errors << "#{path}.cost[#{i}]: a spell's additional cost must be mana, life or a chosen cost (sacrifice, tap, ...)"
+          end
+          new(costs)
+        end
+
+        def self.spell_cost?(cost)
+          return cost.options.all? { spell_cost?(it) } if cost.is_a?(Costs::OneOf)
+
+          cost.mana? || cost.respond_to?(:choices_needed) || cost.respond_to?(:spell_cost?)
+        end
+
+        def initialize(costs, optional: false)
+          super()
+          @costs = costs
+          @optional = optional
+          freeze
+        end
+
+        def mana_ability? = false
+        def allowed_types = nil
+        def try_effects = []
+        def mana_cost = Mana.sum_costs(costs.select(&:mana?).map(&:mana_cost))
+        def choosing_costs = costs.reject(&:mana?)
+        # Recorded as the spell's "kicked_with" when this optional cost is paid.
+        def keyword = self.class.primitive_name.to_s
+        # Whether paying it makes the spell kicked (CR 702.33d).
+        def kicks? = false
+
+        # Whether the non-mana parts can be paid by the spell's controller (CR 118.3).
+        def payable?(engine, spell) = choosing_costs.all? { it.payable?(engine, spell) }
+      end
+
+      # Kicker (CR 702.33a): "You may pay an additional [cost] as you cast this spell." The choice is
+      # announced while casting (CR 601.2b); a kicked spell remembers it (condition {"kicked": true},
+      # CR 702.33d) and may have other targets (`kicked_targets` of its spell ability, CR 702.33g).
+      class Kicker < SpellCost
+        primitive :ability, :kicker,
+                  description: "Kicker: as you cast this spell you may also pay `cost` (mana and/or chosen costs " \
+                               "such as `sacrifice_permanent`). The spell is then kicked: `{\"kicked\": true}` " \
+                               "conditions hold and its `kicked_targets` are used.",
+                  rules: %w[702.33a 702.33d 702.33g 601.2b 601.2f 601.2h],
+                  params: { "cost" => "list of costs, e.g. [{\"mana\": \"{1}{U}\"}]" },
+                  example: { "kicker" => { "cost" => [{ "mana" => "{1}{U}" }] } }
+
+        def kind = :kicker
+        def kicks? = true
+        def to_s = "Kicker #{costs.join(", ")}"
+      end
+
+      # An additional cost: "As an additional cost to cast this spell, sacrifice a creature." (CR 601.2b,
+      # 601.2f-h, 118.8). An optional one ("you may behold a Dragon", CR 118.8b) is announced like kicker (the
+      # `choose_kicker` decision) without making the spell kicked: {"cast_with": "additional_cost"} holds if it
+      # was paid.
+      class AdditionalCost < SpellCost
+        primitive :ability, :additional_cost,
+                  description: "As an additional cost to cast this spell, pay `cost` too (mana and/or chosen costs " \
+                               "such as `sacrifice_permanent`). The spell can't be cast without it. `optional: true`: " \
+                               "you may pay it (announced with the `choose_kicker` decision); the condition " \
+                               "`{\"cast_with\": \"additional_cost\"}` then holds (the spell isn't kicked).",
+                  rules: %w[601.2b 601.2f 601.2h 118.8 118.8b],
+                  params: { "cost" => "list of costs", "optional" => "true: you may pay it" },
+                  example: { "additional_cost" => { "cost" => [{ "sacrifice_permanent" => { "filter" => "creature" } }] } }
+
+        def self.build(params, errors, path, **)
+          optional = Mechanics.flag_param(params, :optional, errors, path)
+          new(super(params.except("optional", :optional), errors, path).costs, optional: optional)
+        end
+
+        def kind = @optional ? :kicker : :additional_cost
+        def to_s = "As an additional cost to cast this spell#{", you may" if @optional}: #{costs.join(", ")}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Abilities
+      # A keyword ability with a number that stands for a triggered ability written in the card DSL
+      # ("Mobilize 2", "Firebending X"). Its `amount` is any amount; it's written into the generated
+      # effects, which validate it.
+      class NumberedTrigger < TriggeredAbility
+        def self.build(params, errors, path, **)
+          Mechanics.check_keys(params, %w[amount], errors, path)
+          amount = Mechanics.fetch_param(params, :amount)
+          errors << "#{path}.amount: required" if amount.nil?
+          data = expansion(amount || 0)
+          trigger = Mechanics.build_entry(:trigger, data["when"], errors, "#{path}.when")
+          body = parse_body(data.except("when"), errors, path)
+          new(**body, effects: (body[:effects] + extra_effects).freeze, trigger: trigger, amount: amount)
+        end
+
+        # Effects the keyword adds after its printed ones (none by default).
+        def self.extra_effects = []
+
+        def initialize(amount: nil, **)
+          @amount = amount
+          super(**)
+        end
+
+        def to_s = "#{self.class.primitive_name.to_s.tr("_", " ").capitalize} #{@amount.is_a?(Integer) ? @amount : "X"}"
+      end
+
+      # Mobilize N (CR 702.181a): "Whenever this creature attacks, create N 1/1 red Warrior creature tokens.
+      # Those tokens enter tapped and attacking. Sacrifice them at the beginning of the next end step."
+      class Mobilize < NumberedTrigger
+        primitive :ability, :mobilize,
+                  description: "Mobilize `amount`: whenever this creature attacks, create that many 1/1 red Warrior " \
+                               "creature tokens tapped and attacking; sacrifice them at the beginning of the next end step.",
+                  rules: %w[702.181a 508.4],
+                  params: { "amount" => "amount" },
+                  example: { "mobilize" => { "amount" => 2 } }
+
+        WARRIOR = { "name" => "Warrior", "types" => ["creature"], "subtypes" => ["warrior"], "colors" => ["R"], "power" => 1,
+                    "toughness" => 1 }.freeze
+
+        def self.expansion(amount)
+          { "when" => { "attacks" => {} },
+            "effects" => [{ "create_token" => { "token" => WARRIOR, "amount" => amount, "tapped" => true, "attacking" => true } },
+                          { "delayed_trigger" => { "when" => { "step_begins" => { "step" => "end", "whose" => "each" } },
+                                                   "effects" => [{ "sacrifice" => { "to" => { "result" => 0 } } }] } }] }
+        end
+      end
+
+      # Firebending N (CR 702.189a): "Whenever this creature attacks, add N {R}. Until end of combat, you
+      # don't lose this mana as steps and phases end."
+      class Firebending < NumberedTrigger
+        primitive :ability, :firebending,
+                  description: "Firebending `amount`: whenever this creature attacks, add that much {R}; you don't " \
+                               "lose this mana as steps end until end of combat.",
+                  rules: %w[702.189a 500.5],
+                  params: { "amount" => "amount" },
+                  example: { "firebending" => { "amount" => 2 } }
+
+        def self.expansion(amount)
+          { "when" => { "attacks" => {} },
+            "effects" => [{ "add_mana" => { "produce" => "{R}", "amount" => amount, "until" => "end_of_combat" } }] }
+        end
+
+        # CR 702.189b: the ability resolving is firebending ("whenever you firebend").
+        def self.extra_effects = @extra_effects ||= [Effects::Firebent.new(to: nil, params: {}, errors: [], path: "firebending")].freeze
+      end
+    end
+
+    module Effects
+      # The last step of a firebending ability: it has resolved, so its controller firebended (CR 702.189b).
+      class Firebent < Effect
+        def self.keys = []
+        def to_s = "(you firebend)"
+
+        def apply(engine, ctx)
+          engine.emit Events::KeywordAction.new(player: engine.name(ctx.controller), action: "firebend", amount: nil)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "../effects/delayed_triggers"
+require_relative "../abilities/play_permissions"
+
+module Enjine
+  module Mechanics
+    module Keywords
+      # Paradigm (CR 702.192a): two spell abilities that follow the spell's own effects. "If this is the first
+      # time a spell you control with this spell's name has resolved this game, at the beginning of each of
+      # your precombat main phases for the rest of the game, create a copy of this object in exile. You may
+      # cast the copy without paying its mana cost" and "Exile this spell." The engine applies them as the
+      # spell finishes resolving (Engine::Resolution#finish_resolution!); the delayed triggered ability is
+      # "delayed:keyword:paradigm" of the spell's card and lasts for the rest of the game.
+      class Paradigm < Primitive
+        primitive :keyword, :paradigm,
+                  description: "As this instant or sorcery finishes resolving: if it's the first time a spell you " \
+                               "control with its name has resolved this game, at the beginning of each of your " \
+                               "precombat main phases for the rest of the game you create a copy of the card in exile " \
+                               "and may cast it without paying its mana cost. Then the spell is exiled.",
+                  rules: %w[702.192a 707.12 603.7 608.2g], example: { "keywords" => ["paradigm"] }
+
+        REF = "delayed:keyword:paradigm"
+
+        # Carries the delayed triggered ability, so the card's data names it (CardDefinition.keyword_delayed).
+        class Rule < Primitive
+          def kind = :paradigm
+          def mana_ability? = false
+          def allowed_types = %i[instant sorcery]
+          def try_effects = [Paradigm.delayed]
+          def to_s = "Paradigm"
+        end
+
+        def self.intrinsic_abilities = @intrinsic_abilities ||= [Rule.new.freeze].freeze
+        def self.delayed = @delayed ||= Effects::ParadigmDelayed.build({}, [], "keyword:paradigm")
+
+        def self.validate(card, errors)
+          types = Array(card["types"]).map(&:to_s)
+          errors << "keywords: paradigm is only for instants and sorceries" unless types.intersect?(%w[instant sorcery])
+        end
+
+        # As the spell finishes resolving: the delayed trigger the first time a spell with its name resolved
+        # for its controller (remembered in their game log), then it's exiled instead of going to the
+        # graveyard. False if the spell doesn't have paradigm.
+        def self.resolved!(engine, spell)
+          chars = engine.chars(spell)
+          return false unless chars.keyword?(:paradigm)
+
+          names = engine.game_log(spell.controller)["paradigm"] ||= []
+          unless names.include?(chars.name)
+            names << chars.name
+            engine.create_delayed_trigger!("controller" => spell.controller, "source" => spell.id, "card" => spell.card,
+                                           "ability" => REF, "game" => true)
+          end
+          engine.move!(spell.id, :exile, reason: "paradigm")
+          true
+        end
+      end
+    end
+
+    module Effects
+      # Paradigm's delayed triggered ability (CR 702.192a): at the beginning of each of your precombat main
+      # phases, create a copy of the card in exile; you may cast it without paying its mana cost (a copy not
+      # cast ceases to exist, CR 707.12). Not a card-data primitive.
+      class ParadigmDelayed < DelayedTrigger
+        MAIN = { "step_begins" => { "step" => "precombat_main", "whose" => "your" } }.freeze
+
+        def self.keys = []
+
+        def setup(_params, errors, path)
+          @ref = "delayed:#{path}"
+          trigger = Mechanics.build_entry(:trigger, MAIN, errors, "#{path}.when")
+          cast = CastFree.build({ "to" => { "result" => 0 } }, errors, "#{path}.cast", results_count: 1)
+          @delayed_ability = Abilities::TriggeredAbility.new(targets: [].freeze, effects: [ParadigmCopy.new, cast].freeze,
+                                                             trigger: trigger)
+        end
+
+        def to_s = "at the beginning of each of your precombat main phases, copy this card in exile; you may cast the copy free"
+      end
+
+      # Creates a copy of the paradigm card (the delayed trigger's card) in exile, owned by its controller.
+      class ParadigmCopy < Effect
+        def self.keys = []
+
+        def initialize = super(to: nil, params: {}, errors: [], path: "paradigm")
+        def apply(engine, ctx) = engine.create_card_copy!([engine.object(ctx.object).card, {}], ctx.controller, :exile)
+        def to_s = "create a copy of this card in exile"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Keywords
+      # Power-up (CR 702.193): "Power-up — [Cost]: [Effect]" is an activated ability written with
+      # `"power_up": true` (Abilities::ActivatedAbility). It can be activated only once, and if its permanent
+      # entered this turn its cost is reduced by the permanent's mana cost (CR 702.193a). Generic mana reduces
+      # generic mana; colored and colorless mana reduce mana of the same type, and any excess reduces generic
+      # mana (CR 702.193b, 118.7b-d). A hybrid symbol reduces by one of its halves (CR 118.7e): the half the cost
+      # needs (a matching colored symbol, then a hybrid symbol that half can pay), otherwise one generic mana.
+      module PowerUp
+        module_function
+
+        # The total cost of `ability` of `source` after the power-up reduction.
+        def reduced(engine, cost, ability, source)
+          return cost unless ability.respond_to?(:power_up?) && ability.power_up?
+
+          obj = engine.state.objects[source]
+          return cost unless obj && engine.entered_this_turn?(obj)
+
+          mana_cost = engine.chars(obj).mana_cost
+          mana_cost ? reduce(cost, mana_cost) : cost
+        end
+
+        # `cost` reduced by the mana cost `reduction` (CR 118.7).
+        def reduce(cost, reduction)
+          colored = cost.colored.dup
+          hybrid = cost.hybrid.dup
+          generic = cost.generic
+          halves = reduction.colored.flat_map { |type, n| Array.new(n) { [type] } } + reduction.hybrid
+          halves.each { generic -= 1 unless reduce_symbol!(colored, hybrid, it) }
+          cost.with(generic: [generic - reduction.generic, 0].max, colored: colored.reject { |_, n| n.zero? }.freeze,
+                    hybrid: hybrid.freeze)
+        end
+
+        # Takes one mana of one of `types` off the colored part, else a hybrid symbol one of them pays.
+        def reduce_symbol!(colored, hybrid, types)
+          type = types.find { colored.fetch(it, 0).positive? }
+          return colored[type] -= 1 if type
+
+          index = hybrid.index { it.intersect?(types) }
+          index && hybrid.delete_at(index)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Abilities
+      # "Hexproof from [quality]" and "protection from [quality]" (CR 702.11d, 702.16): static abilities of a
+      # permanent whose quality is a card spec matched against the spell, or the source of the ability or
+      # damage, as it is now ({"colors": ["B"]} "from black", {"types": ["instant"]} "from instants",
+      # {"color_count": {"equal": 1}} "from monocolored"); "everything" is protection from everything (CR
+      # 702.16j). "From A and from B" is two abilities (CR 702.11f, 702.16g). Two qualities depend on what has
+      # the ability: "each_opponent" (protection from each of your opponents: from everything they control, or own
+      # and nobody controls, CR 702.16i, 702.16k) and "its_colors" ("hexproof from each of its colors": anything
+      # sharing a color with it, CR 702.11g, 702.16h). The engine asks for them by kind
+      # (Engine::Rules#protected_from?).
+      class QualityAbility < Primitive
+        HOLDER_QUALITIES = %w[each_opponent its_colors].freeze
+
+        attr_reader :quality
+
+        # Its value may be the string "everything", "each_opponent" or "its_colors".
+        def self.scalar_params? = true
+
+        def self.build(params, errors, path, **)
+          return new(CardSpec::ANY) if params == "everything"
+          return new(params.to_sym) if HOLDER_QUALITIES.include?(params)
+
+          if params.is_a?(String)
+            errors << "#{path}: must be a card spec, \"everything\", \"each_opponent\" or \"its_colors\""
+            return new(CardSpec::ANY)
+          end
+          new(CardSpec.build(params, errors, path))
+        end
+
+        def initialize(quality)
+          super()
+          @quality = quality
+          freeze
+        end
+
+        def mana_ability? = false
+        def allowed_types = nil
+        def try_effects = []
+        def everything? = quality.equal?(CardSpec::ANY)
+
+        # Whether `object` (a spell, or the source of an ability or of damage) has the quality, for `holder` (the
+        # permanent with the ability, or the index of the player who has it).
+        def from?(engine, object, holder = nil)
+          return false if object.nil?
+
+          case quality
+          when :each_opponent then QualityAbility.opponents?(object, holder)
+          when :its_colors then holder.is_a?(GameObject) && engine.chars(object).colors.intersect?(engine.chars(holder).colors)
+          else quality.match?(engine, object)
+          end
+        end
+
+        # CR 702.16k: the object's controller (or its owner, if nobody controls it) is an opponent of the holder's
+        # controller.
+        def self.opponents?(object, holder)
+          return false if holder.nil?
+
+          (object.controller || object.owner) != (holder.is_a?(Integer) ? holder : holder.controller)
+        end
+
+        def quality_text
+          case quality
+          when :each_opponent then "each of your opponents"
+          when :its_colors then "each of its colors"
+          else everything? ? "everything" : quality.to_s.delete_suffix(" card")
+          end
+        end
+      end
+
+      # Hexproof from [quality] (CR 702.11d): it can't be the target of [quality] spells its controller's
+      # opponents control, or of abilities they control from [quality] sources.
+      class HexproofFrom < QualityAbility
+        primitive :ability, :hexproof_from,
+                  description: "Hexproof from the quality: this permanent can't be the target of spells with the " \
+                               "quality, or abilities from sources with it, that its controller's opponents control. " \
+                               "The quality is a card spec (`{\"colors\": [\"B\"]}`, `{\"types\": [\"instant\"]}`, " \
+                               "`{\"color_count\": {\"equal\": 1}}` for monocolored), or \"its_colors\" (hexproof " \
+                               "from each of its colors: whatever shares a color with it).",
+                  rules: %w[702.11d 702.11f 702.11g 115.4],
+                  params: { "(value)" => "card spec of the quality, or \"its_colors\"" },
+                  example: { "hexproof_from" => { "colors" => ["B"] } }
+
+        def kind = :hexproof_from
+        def to_s = "Hexproof from #{quality_text}"
+      end
+
+      # Protection from [quality] (CR 702.16b-f, "DEBT"): it can't be targeted by spells with the quality or
+      # abilities from sources with it, enchanted or equipped by Auras and Equipment with it, or blocked by
+      # creatures with it, and damage sources with it would deal to it is prevented.
+      class ProtectionFrom < QualityAbility
+        primitive :ability, :protection_from,
+                  description: "Protection from the quality (a card spec, \"everything\", \"each_opponent\": from " \
+                               "each of your opponents, or \"its_colors\"): damage from sources " \
+                               "with the quality is prevented, and this permanent can't be enchanted or equipped " \
+                               "by, blocked by or targeted by anything with the quality (Auras and Equipment " \
+                               "already attached fall off as a state-based action).",
+                  rules: %w[702.16a 702.16b 702.16c 702.16d 702.16e 702.16f 702.16g 702.16h 702.16i 702.16j 702.16k
+                            704.5m 704.5n],
+                  params: { "(value)" => "card spec of the quality, \"everything\", \"each_opponent\" or \"its_colors\"" },
+                  example: { "protection_from" => { "colors" => ["W"] } }
+
+        def kind = :protection_from
+        def to_s = "Protection from #{quality_text}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Enjine
+  module Mechanics
+    module Keywords
+      # Builds the ability a keyword stands for from its card-DSL form, so it behaves exactly like the same
+      # ability printed on a card. The data is fixed, so an error here is a bug.
+      def self.ability_from_data(data, keyword)
+        errors = []
+        ability = Mechanics.build_entry(:ability, data, errors, "keyword:#{keyword}")
+        raise ArgumentError, errors.join("; ") unless errors.empty?
+
+        ability
+      end
+
+      # Prowess (CR 702.108a): "Whenever you cast a noncreature spell, this creature gets +1/+1 until end of
+      # turn." An effect that grants prowess grants this triggered ability too (layer 6, CR 613.1f).
+      class Prowess < Primitive
+        primitive :keyword, :prowess,
+                  description: "Whenever you cast a noncreature spell, this creature gets +1/+1 until end of turn.",
+                  rules: %w[702.108a], example: { "keywords" => ["prowess"] }
+
+        ABILITY = { "triggered" => { "when" => { "cast" => { "controller" => "you", "spell" => "noncreature" } },
+                                     "effects" => [{ "pump" => { "power" => 1, "toughness" => 1, "to" => "self" } }] } }.freeze
+
+        def self.intrinsic_abilities = @intrinsic_abilities ||= [Keywords.ability_from_data(ABILITY, "prowess")].freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../abilities/chosen_values"
+
+module Enjine
+  module Mechanics
+    module Abilities
+      # Riot's "as this enters" choice (CR 702.136a): "counter" (it enters with an additional +1/+1 counter) or
+      # "haste". The choice is remembered like choose_option's ({"chosen": "haste"}).
+      class RiotChoice < ChooseOption
+        INSTANCE = new(%w[counter haste].freeze)
+
+        def to_s = "as this enters, choose a +1/+1 counter or haste"
+        def enters_for(answer) = answer[:option] == "counter" ? super.merge("counters" => { "+1/+1" => 1 }) : super
+      end
+    end
+
+    module Keywords
+      # Riot (CR 702.136a): "You may have this permanent enter with an additional +1/+1 counter on it. If you
+      # don't, it gains haste." Only one "as this enters" choice of a permanent is supported.
+      class Riot < Primitive
+        primitive :keyword, :riot,
+                  description: "As this permanent enters, its controller chooses an additional +1/+1 counter or haste " \
+                               "(an enter_choice: `{type: \"option\", option: \"counter\" | \"haste\"}`).",
+                  rules: %w[702.136a 614.12], example: { "keywords" => ["riot"] }
+
+        HASTE = { "static" => { "affects" => "self", "if" => { "chosen" => "haste" }, "keywords" => ["haste"] } }.freeze
+
+        def self.intrinsic_abilities
+          @intrinsic_abilities ||= [Abilities::RiotChoice::INSTANCE, Keywords.ability_from_data(HASTE, "riot")].freeze
+        end
+      end
+    end
+  end
+end