Integrate Riftbound audit fixes and enforce constructed deck bans

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kai"
-version = "0.21.2"
+version = "0.21.3"
 edition = "2021"
 default-run = "kai"
 

src/ai/driver.rs

@@ -880,11 +880,22 @@ pub fn load_deck(seat: &mut Seat, path: &str, out: &mut Out) {
     }
 }
 
+pub fn deal_rules_enforced(options: Option<&[u8]>) -> bool {
+    agni_riftbound::TableOptions::enforced_in(options)
+}
+
 pub fn deal(seat: &mut Seat, link: &mut dyn Link, out: &mut Out) {
     let Some(record) = seat.deck.as_mut() else {
         out.line("no deck loaded — `deck <file>` first");
         return;
     };
+    let enforced = seat.session.as_ref().is_some_and(|session| {
+        deal_rules_enforced(session.state().options.as_ref().map(|options| &options[..]))
+    });
+    if let Err(error) = crate::deck::actions::validate_deal(&record.deck, enforced) {
+        out.line(format!("deck refused: {error}"));
+        return;
+    }
     record.seat = PlayerId(seat.seat);
     if crate::deck::battlefield::needs_choice(record) {
         out.line("choose a battlefield first: `battlefield <n>`");

src/deck/actions.rs

@@ -47,9 +47,12 @@ pub fn search_cards(cards: &Catalog, query: &str, offset: usize) -> Value {
 
 pub fn inspect(draft: &Draft) -> Value {
     let deck = ImportedDeck::Riftbound(draft.deck.clone());
+    let report = deck
+        .report()
+        .expect("Riftbound decks have legality reports");
     json!({"label": draft.label, "summary": deck.summary(),
         "list": super::exchange::render(&draft.deck, super::exchange::Share::TextList).unwrap_or_default(),
-        "validation": super::import::findings_text(&draft.report), "unresolved": draft.unresolved})
+        "validation": super::import::findings_text(&report), "unresolved": draft.unresolved})
 }
 
 pub fn edit(draft: &mut Option<Draft>, cards: &Catalog, args: &Value) -> Result<Value, String> {
@@ -162,15 +165,24 @@ pub fn selection_legal(verdict: agni_riftbound::legality::Verdict, enforced: boo
     !enforced || !matches!(verdict, agni_riftbound::legality::Verdict::Broken(_))
 }
 
-pub fn validate_selection(draft: &Draft, enforced: bool, confirmed: bool) -> Result<(), String> {
-    if !selection_legal(draft.report.verdict, enforced) {
-        return Err(super::import::findings_text(&draft.report));
+pub fn validate_deal(deck: &ImportedDeck, enforced: bool) -> Result<(), String> {
+    let Some(report) = deck.report() else {
+        return Ok(());
+    };
+    if selection_legal(report.verdict, enforced) {
+        Ok(())
+    } else {
+        Err(super::import::findings_text(&report))
     }
-    if matches!(
-        draft.report.verdict,
-        agni_riftbound::legality::Verdict::Broken(_)
-    ) && !confirmed
-    {
+}
+
+pub fn validate_selection(draft: &Draft, enforced: bool, confirmed: bool) -> Result<(), String> {
+    let deck = ImportedDeck::Riftbound(draft.deck.clone());
+    validate_deal(&deck, enforced)?;
+    let report = deck
+        .report()
+        .expect("Riftbound decks have legality reports");
+    if matches!(report.verdict, agni_riftbound::legality::Verdict::Broken(_)) && !confirmed {
         return Err(
             "This free-table deck is invalid. Confirm explicitly to seat it anyway.".into(),
         );
@@ -304,4 +316,52 @@ mod tests {
             .unwrap()
             .is_empty());
     }
+
+    fn entry(name: &str, id: &str) -> agni_riftbound::DeckEntry {
+        agni_riftbound::DeckEntry {
+            card: agni_riftbound::ResolvedCard {
+                name: name.into(),
+                riftbound_id: id.into(),
+                ..Default::default()
+            },
+            count: 1,
+        }
+    }
+
+    #[test]
+    fn selection_and_deals_recheck_banned_sideboards() {
+        let mut deck = crate::deck::pool::deck("lillia-house").unwrap();
+        deck.sideboard = vec![entry("Stacked Deck", "ogn-183-298")];
+        let imported = ImportedDeck::Riftbound(deck.clone());
+        let report = imported.report().unwrap();
+        assert!(report.findings.iter().any(|finding| {
+            matches!(
+                &finding.rule,
+                agni_riftbound::legality::Rule::Banned { name } if name == "Stacked Deck"
+            ) && finding.zone == agni_riftbound::legality::Zone::Sideboard
+        }));
+        assert!(validate_deal(&imported, true).is_err());
+        assert!(validate_deal(&imported, false).is_ok());
+
+        let mut draft = Draft::from_deck(
+            crate::deck::pool::deck("lillia-house").unwrap(),
+            "stale",
+            Origin::New,
+        );
+        draft.deck = deck;
+        assert!(validate_selection(&draft, true, false).is_err());
+        assert!(validate_selection(&draft, false, false).is_err());
+        assert!(validate_selection(&draft, false, true).is_ok());
+    }
+
+    #[test]
+    fn other_titles_stay_available_to_enforced_deals() {
+        let mut deck = crate::deck::pool::deck("lillia-house").unwrap();
+        deck.main_deck[0].card.name = "Ekko - Another Title".into();
+        let imported = ImportedDeck::Riftbound(deck);
+        assert!(imported.report().unwrap().findings.iter().all(|finding| {
+            !matches!(&finding.rule, agni_riftbound::legality::Rule::Banned { .. })
+        }));
+        assert!(validate_deal(&imported, true).is_ok());
+    }
 }

src/deck/import.rs

@@ -107,6 +107,16 @@ impl ImportedDeck {
         cards
     }
 
+    pub fn report(&self) -> Option<agni_riftbound::legality::Report> {
+        match self {
+            Self::Riftbound(deck) => Some(agni_riftbound::legality::check(
+                deck,
+                agni_riftbound::legality::Mode::Standard,
+            )),
+            Self::Mtg(_) => None,
+        }
+    }
+
     pub fn summary(&self) -> Vec<String> {
         match self {
             Self::Riftbound(deck) => {
@@ -168,9 +178,7 @@ impl ResolvedImport {
     }
 
     pub fn report(&self) -> Option<agni_riftbound::legality::Report> {
-        self.riftbound().map(|deck| {
-            agni_riftbound::legality::check(deck, agni_riftbound::legality::Mode::Standard)
-        })
+        self.deck.report()
     }
 }
 

src/deck/pool.rs

@@ -489,6 +489,24 @@ mod tests {
             }
             let report =
                 agni_riftbound::legality::check(&deck, agni_riftbound::legality::Mode::Standard);
+            if held.slug == "kha-zix-hotkee" {
+                assert_eq!(
+                    deck.main_deck
+                        .iter()
+                        .find(|entry| entry.card.name == "Stacked Deck")
+                        .map(|entry| entry.count),
+                    Some(3)
+                );
+                assert_eq!(report.breaks(), 1, "{:?}", report.findings);
+                assert_eq!(report.verdict, agni_riftbound::legality::Verdict::Broken(1));
+                assert!(report.findings.iter().any(|finding| {
+                    matches!(
+                        &finding.rule,
+                        agni_riftbound::legality::Rule::Banned { name } if name == "Stacked Deck"
+                    )
+                }));
+                continue;
+            }
             assert_eq!(report.breaks(), 0, "{}: {:?}", held.slug, report.findings);
             assert_eq!(
                 report.verdict,

src/menu/editor.rs

@@ -362,7 +362,7 @@ pub fn editor_screen(
     }
     let now = ui.input(|input| input.time);
     for action in actions {
-        run_action(action, now, menu, my_seat, decks);
+        run_action(action, now, enforced, menu, my_seat, decks);
     }
 }
 
@@ -1408,7 +1408,14 @@ pub fn browser_edit(draft: &Draft, catalog: &Catalog, action: BrowserAction) ->
     })
 }
 
-fn run_action(action: Action, now: f64, menu: &mut Menu, my_seat: &MySeat, decks: &mut DeckParams) {
+fn run_action(
+    action: Action,
+    now: f64,
+    enforced: bool,
+    menu: &mut Menu,
+    my_seat: &MySeat,
+    decks: &mut DeckParams,
+) {
     let game_tag = agni_riftbound::GAME.to_string();
     let DeckParams {
         editor,
@@ -1515,6 +1522,12 @@ fn run_action(action: Action, now: f64, menu: &mut Menu, my_seat: &MySeat, decks
             editor::close(editor, menu);
         }
         Action::Seat { next_game } => {
+            if let Err(error) =
+                crate::deck::actions::validate_selection(draft, enforced, sheet.seat_armed)
+            {
+                sheet.status(error, now);
+                return;
+            }
             let saved = if cfg!(target_arch = "wasm32") {
                 Err(WEB_SAVE_NOTE.to_string())
             } else {