Fix Worldspine Wurm duplicate triggers

crates/engine/src/game/casting_costs.rs

@@ -1917,6 +1917,9 @@ fn park_cost_payment_triggers_if_paused(
         .filter(|ev| !matches!(ev, GameEvent::PhaseChanged { .. }))
         .cloned()
         .collect();
+    if crate::game::triggers::pending_trigger_order_owns_event(state, &cost_events) {
+        return;
+    }
     if let Some(mut collection) = state.take_pending_activation_trigger_collection() {
         // CR 602.2b + CR 603.3b: A target-first activation owns cost-trigger
         // collection until its stack entry exists, even when a later payment
@@ -2615,6 +2618,9 @@ fn park_deferred_cost_triggers_if_paused(
         .filter(|ev| !matches!(ev, GameEvent::PhaseChanged { .. }))
         .cloned()
         .collect();
+    if crate::game::triggers::pending_trigger_order_owns_event(state, &cost_events) {
+        return;
+    }
     crate::game::triggers::collect_triggers_into_deferred(state, &cost_events);
 }
 
@@ -2699,6 +2705,9 @@ fn settle_sacrifice_for_cost_events(
     current_end: usize,
 ) {
     if let Some(collection) = pending.activation_trigger_collection.as_mut() {
+        if crate::game::triggers::pending_trigger_order_owns_event(state, &deferred_cost_events) {
+            return;
+        }
         // CR 602.2b + CR 603.2: an announced target-bearing activation owns
         // replacement-paused cost events until its stack commit. Earlier action
         // fragments are not present in this action's event buffer, while the
@@ -2711,6 +2720,9 @@ fn settle_sacrifice_for_cost_events(
     }
 
     deferred_cost_events.extend_from_slice(&events[current_start..current_end]);
+    if crate::game::triggers::pending_trigger_order_owns_event(state, &deferred_cost_events) {
+        return;
+    }
     if !deferred_cost_events.is_empty() {
         crate::game::triggers::collect_triggers_into_deferred(state, &deferred_cost_events);
     }

crates/engine/src/game/triggers.rs

@@ -9894,6 +9894,22 @@ pub(crate) fn filter_consumed_trigger_events(
     filter_consumed_trigger_events_from(events, 0, consumed)
 }
 
+/// CR 603.2c + CR 603.3b: True when an in-flight ordering pass already owns one of the
+/// events in `events` through its pending trigger contexts. A cost handler may
+/// return through an ordering prompt after its own contexts were collected; it
+/// must not park those same events again, while unrelated ordering prompts must
+/// not suppress legitimate cost-event parking.
+pub(crate) fn pending_trigger_order_owns_event(state: &GameState, events: &[GameEvent]) -> bool {
+    state
+        .pending_trigger_order
+        .as_ref()
+        .into_iter()
+        .flat_map(|order| order.groups.iter())
+        .flat_map(|group| group.triggers.iter())
+        .flat_map(|context| context.trigger_events.iter())
+        .any(|trigger_event| events.iter().any(|event| event == trigger_event))
+}
+
 /// CR 603.2c: Remove from `events[event_start..]` the occurrences a trigger
 /// collector has already taken, so a second collector over the same raw slice
 /// cannot fire the same observers twice.
@@ -14324,8 +14340,8 @@ pub mod tests {
     use crate::types::game_state::{
         DamageRecord, DeferredLifeCostResume, DelayedTrigger, DistributionUnit, GameState,
         LayersDirty, LoopDetectionMode, NamedChoiceSourceBinding, PendingCast,
-        PendingCostMoveResume, SpellCastRecord, StackEntry, StackEntryKind,
-        TransientContinuousEffect, WaitingFor, ZoneChangeRecord,
+        PendingCostMoveResume, PendingTriggerOrder, SpellCastRecord, StackEntry, StackEntryKind,
+        TransientContinuousEffect, TriggerOrderGroup, WaitingFor, ZoneChangeRecord,
     };
     use crate::types::identifiers::{
         CardId, DelayedTriggerInstanceId, DelayedTriggerOrigin, DelayedTriggerToken, ObjectId,
@@ -14342,6 +14358,56 @@ pub mod tests {
         GameState::new_two_player(42)
     }
 
+    fn ordering_with_event(event: GameEvent) -> PendingTriggerOrder {
+        let mut pending = PendingTrigger::ordinary(
+            ObjectId(1),
+            PlayerId(0),
+            None,
+            Box::new(ResolvedAbility::new(
+                Effect::GainLife {
+                    amount: QuantityExpr::Fixed { value: 1 },
+                    player: TargetFilter::Controller,
+                },
+                Vec::new(),
+                ObjectId(1),
+                PlayerId(0),
+            )),
+            0,
+        );
+        pending.trigger_event = Some(event);
+        PendingTriggerOrder {
+            groups: vec![TriggerOrderGroup {
+                controller: PlayerId(0),
+                triggers: vec![PendingTriggerContext::single(pending)],
+                ordered: false,
+            }],
+            resume_after_ordering: None,
+        }
+    }
+
+    #[test]
+    fn pending_trigger_order_owns_matching_event() {
+        let event = GameEvent::GameStarted;
+        let mut state = setup();
+        state.pending_trigger_order = Some(ordering_with_event(event.clone()));
+
+        assert!(pending_trigger_order_owns_event(&state, &[event]));
+    }
+
+    #[test]
+    fn pending_trigger_order_does_not_own_unrelated_event() {
+        let mut state = setup();
+        state.pending_trigger_order = Some(ordering_with_event(GameEvent::GameStarted));
+
+        assert!(!pending_trigger_order_owns_event(
+            &state,
+            &[GameEvent::TurnStarted {
+                player_id: PlayerId(0),
+                turn_number: 1,
+            }],
+        ));
+    }
+
     #[test]
     fn abandon_ceased_pending_trigger_recovers_when_its_stack_firing_was_pruned() {
         let mut state = setup();

crates/engine/tests/integration/issue_worldspine_wurm_duplicate_triggers.rs

@@ -0,0 +1,113 @@
+//! Regression coverage for duplicate Worldspine Wurm triggers during a
+//! Recurring Nightmare activation.
+
+use engine::database::card_db::CardDatabase;
+use engine::game::scenario::{GameScenario, P0};
+use engine::game::scenario_db::GameScenarioDbExt;
+use engine::types::ability::TargetRef;
+use engine::types::actions::GameAction;
+use engine::types::game_state::{PayCostKind, StackEntryKind, WaitingFor};
+use engine::types::identifiers::ObjectId;
+use engine::types::mana::{ManaType, ManaUnit};
+use engine::types::phase::Phase;
+use engine::types::zones::Zone;
+
+use crate::support::shared_card_db;
+
+fn card_db() -> &'static CardDatabase {
+    shared_card_db().expect("integration card fixture must load")
+}
+
+#[test]
+fn worldspine_wurm_sacrifice_creates_each_trigger_once() {
+    let db = card_db();
+    let mut scenario = GameScenario::new();
+    scenario.at_phase(Phase::PreCombatMain);
+    scenario.with_mana_pool(
+        P0,
+        vec![
+            ManaUnit::new(ManaType::Colorless, ObjectId(9_998), false, vec![]),
+            ManaUnit::new(ManaType::Colorless, ObjectId(9_999), false, vec![]),
+            ManaUnit::new(ManaType::Black, ObjectId(10_000), false, vec![]),
+        ],
+    );
+
+    let wurm = scenario.add_real_card(P0, "Worldspine Wurm", Zone::Battlefield, db);
+    let nightmare = scenario.add_real_card(P0, "Recurring Nightmare", Zone::Battlefield, db);
+    let graveyard_creature = scenario.add_real_card(P0, "Grizzly Bears", Zone::Graveyard, db);
+    let _other_graveyard_creature =
+        scenario.add_real_card(P0, "Elvish Mystic", Zone::Graveyard, db);
+    let mut runner = scenario.build();
+    let ability_index = runner.state().objects[&nightmare]
+        .abilities
+        .iter()
+        .position(|ability| matches!(ability.kind, engine::types::ability::AbilityKind::Activated))
+        .expect("Recurring Nightmare must have an activated ability");
+
+    runner
+        .act(GameAction::ActivateAbility {
+            source_id: nightmare,
+            ability_index,
+        })
+        .expect("begin Recurring Nightmare activation");
+
+    let mut saw_sacrifice = false;
+    let mut saw_target = false;
+    for _ in 0..32 {
+        match runner.state().waiting_for.clone() {
+            WaitingFor::TargetSelection { .. } => {
+                runner
+                    .act(GameAction::SelectTargets {
+                        targets: vec![TargetRef::Object(graveyard_creature)],
+                    })
+                    .expect("select Recurring Nightmare target");
+                saw_target = true;
+            }
+            WaitingFor::PayCost {
+                kind: PayCostKind::Sacrifice,
+                ..
+            } => {
+                runner
+                    .act(GameAction::SelectCards { cards: vec![wurm] })
+                    .expect("sacrifice Worldspine Wurm");
+                saw_sacrifice = true;
+            }
+            WaitingFor::ManaPayment { .. } => {
+                runner
+                    .act(GameAction::PassPriority)
+                    .expect("pay Recurring Nightmare's mana cost");
+            }
+            WaitingFor::OrderTriggers { .. } => {
+                engine::game::triggers::drain_order_triggers_with_identity(runner.state_mut());
+            }
+            WaitingFor::Priority { .. } => break,
+            other => panic!("unexpected waiting state during activation: {other:?}"),
+        }
+    }
+
+    assert!(saw_sacrifice, "activation must sacrifice Worldspine Wurm");
+    assert!(saw_target, "activation must choose a graveyard creature");
+
+    // Without the cost-event ownership check, the sacrifice event is parked a
+    // second time while this ordering prompt is being returned, producing four
+    // Wurm trigger entries instead of the two below.
+    let wurm_triggers: Vec<_> = runner
+        .state()
+        .stack
+        .iter()
+        .filter(|entry| entry.source_id == wurm)
+        .filter_map(|entry| match &entry.kind {
+            StackEntryKind::TriggeredAbility { description, .. } => description.clone(),
+            _ => None,
+        })
+        .collect();
+    assert_eq!(
+        wurm_triggers,
+        vec![
+            "When ~ dies, create three 5/5 green Wurm creature tokens with trample.".to_string(),
+            "When ~ is put into a graveyard from anywhere, shuffle it into its owner's library."
+                .to_string(),
+        ],
+        "a single Battlefield-to-Graveyard move must create one of each Wurm trigger",
+    );
+}

crates/engine/tests/integration/main.rs

@@ -769,6 +769,7 @@ mod issue_bound_by_moonsilver_sacrifice_attach;
 mod issue_circle_of_protection_source_choice;
 mod issue_desperate_gambit_choose_damage_source;
 mod issue_haze_frog_other_creature_prevention;
+mod issue_worldspine_wurm_duplicate_triggers;
 mod ivory_gargoyle_temporal_and_skip_tail;
 mod jace_wielder_empty_library_win;
 mod jagged_lightning_each_of_two_targets;