Phase 7 (Core): chemistry v2, expanded card pool & search filters

- Chemistry v2: FUT-style link scoring with per-player breakdown
  (club +3/link cap 6, league +1/link cap 4, nation +1/link cap 3;
   player cap 10, team cap 100); chemistry response now includes
   per-player breakdown with club/league/nation link counts and pts
- Card pool: 34 new cards across Premier League, La Liga, Bundesliga
  with overlapping clubs/nations for meaningful chemistry testing
- Card search: extended GET /cards with nation, league, club,
  min_overall, max_overall, limit query params; results sorted by
  overall descending
- Match opponent: added "ultimate" difficulty band (85+ OVR);
  random formation selection from 6 tactical formations; falls back
  to lower OVR pool when not enough cards at the requested band
- Tests: 9 new integration tests (28 total, all passing)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/routes/cards.rs

@@ -16,6 +16,12 @@ use crate::{
 pub struct CardQuery {
     pub rarity: Option<String>,
     pub position: Option<String>,
+    pub nation: Option<String>,
+    pub league: Option<String>,
+    pub club: Option<String>,
+    pub min_overall: Option<u8>,
+    pub max_overall: Option<u8>,
+    pub limit: Option<usize>,
 }
 
 pub async fn get_card(
@@ -33,25 +39,49 @@ pub async fn get_cards(
     State(state): State<AppState>,
     Query(query): Query<CardQuery>,
 ) -> AppResult<Json<Value>> {
-    let cards = state
+    let mut cards: Vec<_> = state
         .card_db
         .all()
         .into_iter()
         .filter(|c| {
-            query
+            let rarity_ok = query
                 .rarity
                 .as_ref()
                 .map(|r| format!("{:?}", c.rarity).to_lowercase() == r.to_lowercase())
-                .unwrap_or(true)
-                && query
-                    .position
-                    .as_ref()
-                    .map(|p| c.position.to_lowercase() == p.to_lowercase())
-                    .unwrap_or(true)
+                .unwrap_or(true);
+            let pos_ok = query
+                .position
+                .as_ref()
+                .map(|p| c.position.eq_ignore_ascii_case(p))
+                .unwrap_or(true);
+            let nation_ok = query
+                .nation
+                .as_ref()
+                .map(|n| c.nation.eq_ignore_ascii_case(n))
+                .unwrap_or(true);
+            let league_ok = query
+                .league
+                .as_ref()
+                .map(|l| c.league.eq_ignore_ascii_case(l))
+                .unwrap_or(true);
+            let club_ok = query
+                .club
+                .as_ref()
+                .map(|cl| c.club.eq_ignore_ascii_case(cl))
+                .unwrap_or(true);
+            let min_ok = query.min_overall.map(|m| c.overall >= m).unwrap_or(true);
+            let max_ok = query.max_overall.map(|m| c.overall <= m).unwrap_or(true);
+            rarity_ok && pos_ok && nation_ok && league_ok && club_ok && min_ok && max_ok
         })
-        .collect::<Vec<_>>();
+        .collect();
 
-    Ok(Json(json!({ "cards": cards, "total": cards.len() })))
+    cards.sort_by_key(|c| std::cmp::Reverse(c.overall));
+    let total = cards.len();
+    if let Some(limit) = query.limit {
+        cards.truncate(limit);
+    }
+
+    Ok(Json(json!({ "cards": cards, "total": total, "returned": cards.len() })))
 }
 
 pub async fn get_collection(State(state): State<AppState>) -> AppResult<Json<Value>> {

src/services/match_service.rs

@@ -9,73 +9,70 @@ use crate::{
 };
 use rand::{seq::SliceRandom, Rng};
 
+const FORMATIONS: &[&str] = &[
+    "4-3-3", "4-4-2", "4-2-3-1", "4-1-2-1-2", "3-5-2", "5-3-2",
+];
+
 /// Generate a random AI opponent squad for Squad Battles.
+///
+/// Difficulty bands:
+///   beginner     — overall 55+  (same as "any")
+///   professional — overall 70+
+///   world_class  — overall 78+
+///   legendary    — overall 85+
+///   ultimate     — overall 90+
 pub fn generate_opponent(card_db: &CardDb, difficulty: &str) -> serde_json::Value {
     let (min_overall, names): (u8, &[&str]) = match difficulty {
         "professional" => (
             70,
-            &[
-                "Athletic CF",
-                "City Wanderers",
-                "The Rovers",
-                "United Select",
-                "Blue Stars FC",
-            ],
+            &["Athletic CF", "City Wanderers", "The Rovers", "United Select", "Blue Stars FC"],
         ),
         "world_class" => (
             78,
-            &[
-                "Elite Stars FC",
-                "Champions Select",
-                "Premier XI",
-                "Galaxy United",
-                "Titan FC",
-            ],
+            &["Elite Stars FC", "Champions Select", "Premier XI", "Galaxy United", "Titan FC"],
         ),
         "legendary" => (
             85,
-            &[
-                "Legends United",
-                "Ultimate XI",
-                "Gold Standard FC",
-                "The Icons",
-                "Heritage FC",
-            ],
+            &["Legends United", "Ultimate XI", "Gold Standard FC", "The Icons", "Heritage FC"],
+        ),
+        "ultimate" => (
+            90,
+            &["Apex XI", "Pantheon FC", "Gods of FUT", "Invincibles Select", "Eternal XI"],
         ),
         _ => (
-            58,
-            &[
-                "Amateur Town FC",
-                "Sunday League XI",
-                "Park FC",
-                "Village Stars",
-                "Reserve XI",
-            ],
+            55,
+            &["Amateur Town FC", "Sunday League XI", "Park FC", "Village Stars", "Reserve XI"],
         ),
     };
 
     let mut rng = rand::thread_rng();
     let all = card_db.by_min_overall(min_overall);
-    let mut indices: Vec<usize> = (0..all.len()).collect();
+
+    // Fall back to lower overall band if not enough cards at this difficulty
+    let pool: Vec<_> = if all.len() >= 11 {
+        all
+    } else {
+        card_db.by_min_overall(55)
+    };
+
+    let mut indices: Vec<usize> = (0..pool.len()).collect();
     indices.shuffle(&mut rng);
-    let cards: Vec<_> = indices
-        .into_iter()
-        .take(11)
-        .map(|i| all[i].clone())
-        .collect();
+    let cards: Vec<_> = indices.into_iter().take(11).map(|i| pool[i].clone()).collect();
 
     let squad_rating = if cards.is_empty() {
         0
     } else {
         cards.iter().map(|c| c.overall as i64).sum::<i64>() / cards.len() as i64
     };
+
     let name = names[rng.gen_range(0..names.len())];
+    let formation = FORMATIONS[rng.gen_range(0..FORMATIONS.len())];
 
     serde_json::json!({
         "opponent_name": name,
         "difficulty": difficulty,
         "squad_rating": squad_rating,
-        "formation": "4-4-2",
+        "formation": formation,
         "cards": cards,
     })
 }

src/services/squad.rs

@@ -105,6 +105,15 @@ pub async fn validate_formation(
     Ok(())
 }
 
+/// Chemistry v2: FUT-style link scoring.
+///
+/// Each player earns up to 10 chemistry from three link types:
+///   - Club links:   strongest signal — +3 per shared club teammate (max 6 pts)
+///   - League links: medium signal    — +1 per shared league mate   (max 4 pts)
+///   - Nation links: weakest signal   — +1 per shared nation mate   (max 3 pts)
+///
+/// Individual player chemistry is capped at 10.
+/// Team chemistry = sum of all player chemistries, capped at 100.
 pub async fn calculate_chemistry(
     pool: &Pool,
     card_db: &CardDb,
@@ -112,10 +121,12 @@ pub async fn calculate_chemistry(
 ) -> AppResult<serde_json::Value> {
     let starters: Vec<&SquadPlayer> = players.iter().filter(|p| !p.is_on_bench).collect();
 
-    let mut cards: Vec<CardDefinition> = Vec::new();
+    // Load all starter card definitions (N separate queries, fine for 11 players)
+    let mut player_cards: Vec<(String, CardDefinition)> = Vec::new();
     for sp in &starters {
         let owned = sqlx::query_as::<_, OwnedCard>(
-            "SELECT id, club_id, card_id, is_loan, loan_matches_remaining, acquired_at FROM owned_cards WHERE id = ?",
+            "SELECT id, club_id, card_id, is_loan, loan_matches_remaining, acquired_at \
+             FROM owned_cards WHERE id = ?",
         )
         .bind(&sp.owned_card_id)
         .fetch_optional(pool)
@@ -123,43 +134,60 @@ pub async fn calculate_chemistry(
 
         if let Some(o) = owned {
             if let Some(card) = card_db.get(&o.card_id) {
-                cards.push(card.clone());
+                player_cards.push((sp.owned_card_id.clone(), card.clone()));
             }
         }
     }
 
-    let player_chems: Vec<i64> = cards
-        .iter()
-        .enumerate()
-        .map(|(i, c)| {
-            let same_club = cards
-                .iter()
-                .enumerate()
-                .filter(|(j, o)| *j != i && o.club == c.club)
-                .count()
-                .min(4) as i64;
-            let same_league = cards
-                .iter()
-                .enumerate()
-                .filter(|(j, o)| *j != i && o.league == c.league)
-                .count()
-                .min(3) as i64;
-            let same_nation = cards
-                .iter()
-                .enumerate()
-                .filter(|(j, o)| *j != i && o.nation == c.nation)
-                .count()
-                .min(3) as i64;
-            (same_club + same_league + same_nation).min(10)
-        })
-        .collect();
+    let mut player_chemistries = Vec::with_capacity(player_cards.len());
+    let mut total_chem: i64 = 0;
 
-    let total: i64 = player_chems.iter().sum::<i64>().min(100);
+    for (i, (owned_id, card)) in player_cards.iter().enumerate() {
+        let club_links = player_cards
+            .iter()
+            .enumerate()
+            .filter(|(j, (_, c))| *j != i && c.club == card.club)
+            .count() as i64;
+        let league_links = player_cards
+            .iter()
+            .enumerate()
+            .filter(|(j, (_, c))| *j != i && c.league == card.league)
+            .count() as i64;
+        let nation_links = player_cards
+            .iter()
+            .enumerate()
+            .filter(|(j, (_, c))| *j != i && c.nation == card.nation)
+            .count() as i64;
+
+        let club_pts = (club_links * 3).min(6);
+        let league_pts = league_links.min(4);
+        let nation_pts = nation_links.min(3);
+        let player_chem = (club_pts + league_pts + nation_pts).min(10);
+
+        total_chem += player_chem;
+        player_chemistries.push(serde_json::json!({
+            "owned_card_id": owned_id,
+            "card_id": &card.id,
+            "name": &card.name,
+            "chemistry": player_chem,
+            "breakdown": {
+                "club_links": club_links,
+                "league_links": league_links,
+                "nation_links": nation_links,
+                "club_pts": club_pts,
+                "league_pts": league_pts,
+                "nation_pts": nation_pts,
+            }
+        }));
+    }
+
+    let team_chemistry = total_chem.min(100);
 
     Ok(serde_json::json!({
-        "total": total,
+        "total": team_chemistry,
         "max": 100,
-        "player_chemistries": player_chems,
+        "player_count": player_chemistries.len(),
+        "player_chemistries": player_chemistries,
     }))
 }