feat: limit medium-probability cards and sync Docker dev dependencies

src/lib/engine/combination-search.test.ts

@@ -5,7 +5,8 @@ import {
   generateAnchoredCombinationCandidates,
   generateCombinationCandidates,
   resolveCandidateAwakening,
-  selectMemberDiverseCandidates
+  selectMemberDiverseCandidates,
+  withinMediumProbabilityCardLimit
 } from './index.ts';
 
 const cards = [
@@ -15,6 +16,57 @@ const cards = [
   { id: 'c-1', characterId: 'c', score: 40 }
 ];
 
+const probabilityCards = [46, 46, 55, 55, 55, 55].map((probabilityPercent, index) => ({
+  id: String(index),
+  characterId: String(index),
+  score: 100 - index,
+  details: { active: [{ probabilityPercent }, { probabilityPercent }] }
+}));
+
+test('중간 확률은 스킬 레벨 수와 무관하게 카드당 한 장으로 세고 낮음은 제외한다', () => {
+  assert.equal(withinMediumProbabilityCardLimit([probabilityCards[0]], 1), true);
+  assert.equal(withinMediumProbabilityCardLimit([probabilityCards[0]], 0), false);
+  assert.equal(withinMediumProbabilityCardLimit([
+    probabilityCards[2],
+    { details: { active: [{ probabilityPercent: 37 }] } },
+    { details: { active: [] } }
+  ], 0), true);
+  assert.equal(withinMediumProbabilityCardLimit(probabilityCards, null), true);
+});
+
+test('높은 점수의 중간 확률 카드가 빔을 독점하기 전에 제한을 적용한다', () => {
+  const result = generateCombinationCandidates([], probabilityCards, 5, (card) => card.score, 1,
+    undefined, (selected) => withinMediumProbabilityCardLimit(selected, 1));
+  assert.equal(result.length, 1);
+  assert.deepEqual(result[0].map((card) => card.id).sort(), ['0', '2', '3', '4', '5']);
+});
+
+test('고정 카드도 중간 확률 제한에 포함하고 초과하거나 완성할 수 없으면 후보를 반환하지 않는다', () => {
+  const accepts = (selected: readonly (typeof probabilityCards)[number][]) => withinMediumProbabilityCardLimit(selected, 1);
+  const result = generateCombinationCandidates([probabilityCards[1]], probabilityCards, 5, (card) => card.score, 10, undefined, accepts);
+  assert.equal(result.length, 1);
+  assert.ok(result[0].some((card) => card.id === '1'));
+  assert.ok(result[0].every((card) => card.id !== '0'));
+  assert.deepEqual(generateCombinationCandidates(probabilityCards.slice(0, 2), probabilityCards, 5,
+    (card) => card.score, 10, undefined, accepts), []);
+  assert.deepEqual(generateCombinationCandidates([], probabilityCards, 5,
+    (card) => card.score, 10, undefined, (selected) => withinMediumProbabilityCardLimit(selected, 0)), []);
+});
+
+test('임시 축 후보에도 제한을 적용하고 중간 확률 카드를 모두 제외할 수 있다', () => {
+  const result = generateAnchoredCombinationCandidates([], probabilityCards, 3,
+    [{ scoreCard: (card) => card.score }], 1,
+    (selected) => withinMediumProbabilityCardLimit(selected, 0));
+  assert.ok(result.length > 0);
+  assert.ok(result.every((selected) => selected.every((card) => card.details.active[0].probabilityPercent === 55)));
+});
+
+test('제한 없음은 기존 조합 후보를 그대로 유지한다', () => {
+  const expected = generateCombinationCandidates([], probabilityCards, 5, (card) => card.score, 10);
+  assert.deepEqual(generateCombinationCandidates([], probabilityCards, 5, (card) => card.score, 10,
+    undefined, (selected) => withinMediumProbabilityCardLimit(selected, null)), expected);
+});
+
 test('고정 카드를 유지하고 같은 멤버의 이격 카드를 제외한다', () => {
   const result = generateCombinationCandidates([cards[0]], cards, 3, (card) => card.score, 20);
   assert.equal(result.length, 1);

src/lib/engine/combination-search.ts

@@ -23,6 +23,15 @@ export type CombinationScoringStrategy<T extends CombinationSearchCard> = {
 const SCREENING_LIMIT_PER_OPEN_SLOT = 5_000;
 const EXACT_FINALIST_LIMIT_PER_OPEN_SLOT = 56;
 
+export function withinMediumProbabilityCardLimit(
+  cards: readonly { details: { active: readonly { probabilityPercent?: number | null }[] } }[],
+  maximum: number | null
+): boolean {
+  return maximum === null || cards.filter((card) =>
+    card.details.active.some((level) => level.probabilityPercent === 46)
+  ).length <= maximum;
+}
+
 export function combinationSearchLimits(fixedCardCount: number, targetSize = 5): CombinationSearchLimits {
   const normalizedTargetSize = Math.max(1, Math.floor(targetSize));
   const normalizedFixedCardCount = Math.min(normalizedTargetSize, Math.max(0, Math.floor(fixedCardCount)));
@@ -49,12 +58,15 @@ export function generateCombinationCandidates<T extends CombinationSearchCard>(
   targetSize: number,
   scoreCard: (card: T) => number,
   beamWidth = 800,
-  scoreCombination?: (cards: readonly T[]) => number
+  scoreCombination?: (cards: readonly T[]) => number,
+  // Must accept valid partial combinations, as it is checked at every expansion.
+  acceptsCombination?: (cards: readonly T[]) => boolean
 ): T[][] {
   if (targetSize < fixedCards.length) throw new Error('목표 카드 수가 고정 카드 수보다 작습니다.');
   if (new Set(fixedCards.map((card) => card.characterId)).size !== fixedCards.length) {
     throw new Error('같은 멤버를 두 번 고정할 수 없습니다.');
   }
+  if (acceptsCombination && !acceptsCombination(fixedCards)) return [];
   const fixedIds = new Set(fixedCards.map((card) => card.id));
   const fixedCharacters = new Set(fixedCards.map((card) => card.characterId));
   const pool = candidateCards.filter((card) => !fixedIds.has(card.id) && !fixedCharacters.has(card.characterId));
@@ -72,6 +84,7 @@ export function generateCombinationCandidates<T extends CombinationSearchCard>(
         if (usedIds.has(card.id)) continue;
         if (usedCharacters.has(card.characterId)) continue;
         const cards = [...state.cards, card];
+        if (acceptsCombination && !acceptsCombination(cards)) continue;
         const nextState = {
           cards,
           score: scoreCombination?.(cards) ?? state.score + scoreCard(card)
@@ -96,7 +109,8 @@ export function generateAnchoredCombinationCandidates<T extends CombinationSearc
   candidateCards: readonly T[],
   targetSize: number,
   strategies: readonly CombinationScoringStrategy<T>[],
-  perAnchorLimit: number
+  perAnchorLimit: number,
+  acceptsCombination?: (cards: readonly T[]) => boolean
 ): T[][] {
   if (strategies.length === 0 || perAnchorLimit <= 0 || fixedCards.length >= targetSize) return [];
   const fixedCharacters = new Set(fixedCards.map((card) => card.characterId));
@@ -113,7 +127,8 @@ export function generateAnchoredCombinationCandidates<T extends CombinationSearc
         targetSize,
         strategy.scoreCard,
         perStrategyLimit,
-        strategy.scoreCombination
+        strategy.scoreCombination,
+        acceptsCombination
       )) {
         anchored.set(cards.map((card) => card.id).sort().join('|'), cards);
       }

src/routes/combination/+page.svelte

@@ -29,7 +29,8 @@
     perfectNoteScoreFromPower,
     resolveCandidateAwakening,
     selectMemberDiverseCandidates,
-    toOptimizerCard
+    toOptimizerCard,
+    withinMediumProbabilityCardLimit
   } from '$lib/engine/index.ts';
   import type { CooldownReduction, ExactOptimizationResult, ExactSongChart, OptimizationProgress, OptimizerCard, ScoreAchievementProbabilities } from '$lib/engine/index.ts';
   import { USER_DATA_STORAGE_KEY } from '$lib/storage/browser-storage';
@@ -77,6 +78,7 @@
     fixedGenerationBonusOverrides?: (number | null)[];
     songScoreBonusOverride?: number | null;
     ownedCardsOnly?: boolean;
+    maxMediumProbabilityCards?: number | null;
     maximizeCompute?: boolean;
     leaderCharacterId: string;
     leaderOutfitCardId: string;
@@ -136,6 +138,7 @@
   let fixedGenerationBonusOverrides: (number | null)[] = [null, null, null, null];
   let songScoreBonusOverride: number | null = 10;
   let ownedCardsOnly = false;
+  let maxMediumProbabilityCards: number | null = null;
   let maximizeCompute = false;
   let leaderCharacterId = leaderMembers[0]?.characterId ?? '';
   let leaderOutfitCardId = leaderMembers[0]?.id ?? '';
@@ -220,6 +223,7 @@
     fixedGenerationBonusOverrides,
     songScoreBonusOverride,
     ownedCardsOnly,
+    maxMediumProbabilityCards,
     maximizeCompute,
     leaderCharacterId,
     leaderOutfitCardId
@@ -237,6 +241,7 @@
     fixedGenerationBonusOverrides,
     songScoreBonusOverride,
     ownedCardsOnly,
+    maxMediumProbabilityCards,
     maximizeCompute,
     leaderCharacterId,
     leaderOutfitCardId
@@ -382,6 +387,9 @@
       ? null
       : normalizeSongScoreBonusOverride(state.songScoreBonusOverride) ?? 10;
     ownedCardsOnly = state.ownedCardsOnly === true;
+    maxMediumProbabilityCards = typeof state.maxMediumProbabilityCards === 'number' &&
+      Number.isInteger(state.maxMediumProbabilityCards) && state.maxMediumProbabilityCards >= 0 && state.maxMediumProbabilityCards < 5
+      ? state.maxMediumProbabilityCards : null;
     if (ownedCardsOnly) toggleOwnedCardsOnly(true);
     maximizeCompute = state.maximizeCompute === true;
     if (typeof state.leaderCharacterId === 'string' && leaderMembers.some((member) => member.characterId === state.leaderCharacterId)) {
@@ -598,11 +606,15 @@
     return boards;
   }
 
+  function acceptsCombination(cards: readonly CardRow[]): boolean {
+    return withinMediumProbabilityCardLimit(cards, maxMediumProbabilityCards);
+  }
+
   function screeningCombinations(): CardRow[][] {
     const limits = combinationSearchLimits(fixedCards.length);
     const screeningLimit = eventMode ? Math.min(limits.screeningLimit, 9_000) : limits.screeningLimit;
     if (fixedCards.length === 4) {
-      return generateCombinationCandidates(fixedCards, candidateCards, 5, roughCardScore, screeningLimit);
+      return generateCombinationCandidates(fixedCards, candidateCards, 5, roughCardScore, screeningLimit, undefined, acceptsCombination);
     }
     const globalBudget = eventMode ? screeningLimit : Math.ceil(screeningLimit * 0.8);
     const anchoredBudget = screeningLimit - globalBudget;
@@ -627,7 +639,8 @@
         5,
         strategy.scoreCard,
         perStrategy,
-        strategy.scoreCombination
+        strategy.scoreCombination,
+        acceptsCombination
       )) {
         combined.set(combinationKey(cards), cards);
       }
@@ -641,7 +654,8 @@
       candidateCards,
       5,
       strategies,
-      perAnchorLimit
+      perAnchorLimit,
+      acceptsCombination
     )) {
       combined.set(combinationKey(cards), cards);
     }
@@ -699,6 +713,7 @@
         for (const replacement of candidateCards) {
           if (replacement.id === source.id || otherCharacters.has(replacement.characterId)) continue;
           const cards = sourceCards.map((card, cardIndex) => cardIndex === index ? replacement : card);
+          if (!acceptsCombination(cards)) continue;
           const key = combinationKey(cards);
           if (key === sourceKey) continue;
           const candidate = alternatives.get(key) ?? { cards, roughScore: roughCombinationScore(cards) };
@@ -1001,6 +1016,10 @@
       errorMessage = '같은 멤버의 일반 카드와 이격 카드는 함께 고정할 수 없습니다.';
       return;
     }
+    if (!acceptsCombination(fixedCards)) {
+      errorMessage = `고정 카드의 액티브 발동 확률 ‘중간’ 카드가 최대 ${maxMediumProbabilityCards}장 제한을 초과합니다. 고정 카드나 제한을 변경해 주세요.`;
+      return;
+    }
     running = true;
     searchPhase = 'screening';
     exactPass = 'primary';
@@ -1158,6 +1177,15 @@
       <label>자동 후보 기수 보너스 덮어쓰기 (0~900)<input class="number-input" type="text" inputmode="numeric" pattern="[0-9]*" maxlength="3" value={candidateGenerationBonus ?? ''} placeholder="미사용" on:input={(event) => updateCandidateGenerationBonus(sanitizeGenerationBonusInput(event.currentTarget, candidateGenerationBonus))}></label>
       <label>가창 보너스 덮어쓰기 (0~10%)<input class="number-input" type="number" min="0" max="10" step="any" value={songScoreBonusOverride ?? ''} placeholder="실제 보드값" on:input={(event) => updateSongScoreBonusOverride(event.currentTarget)}></label>
     </div>
+    <div class="probability-limit-field">
+      <label>액티브 발동 확률 ‘중간’ 카드 최대 장수
+        <select bind:value={maxMediumProbabilityCards} disabled={running} aria-describedby="probability-limit-guide" on:change={() => { result = null; errorMessage = ''; }}>
+          <option value={null}>제한 없음</option>
+          {#each [0, 1, 2, 3, 4] as count}<option value={count}>{count}장{count === 0 ? ' (사용 안 함)' : ' 이하'}</option>{/each}
+        </select>
+      </label>
+      <p id="probability-limit-guide" class="candidate-guide">고정 카드를 포함한 5장 전체에 적용합니다. 보드의 발동률 증가와 관계없이 카드의 기본 확률을 기준으로 셉니다.</p>
+    </div>
     <label class="owned-cards-option">
       <input type="checkbox" checked={ownedCardsOnly} disabled={running} on:change={(event) => toggleOwnedCardsOnly(event.currentTarget.checked)}>
       <span aria-hidden="true"></span>
@@ -1321,6 +1349,8 @@
   .candidate-fields { display: grid; grid-template-columns: clamp(130px, 12vw, 180px) repeat(2, clamp(230px, 21vw, 340px)); gap: 9px; margin-top: 18px; }
   .candidate-awakening { display: grid; gap: 7px; color: #8f98a8; font-size: 14px; font-weight: 750; }
   .candidate-guide { margin: 7px 0 0; color: #737d8d; font-size: 12px; line-height: 1.5; }
+  .probability-limit-field { margin-top: 16px; }
+  .probability-limit-field > label { max-width: 340px; }
   .fixed-fields { display: grid; gap: 9px; margin-top: 16px; }
   .fixed-guide { margin: 8px 0 0; color: #737d8d; font-size: 12px; line-height: 1.5; }
   .fixed-column-headings { display: grid; grid-template-columns: minmax(320px, 1fr) clamp(130px, 12vw, 180px) clamp(304px, 27vw, 400px) clamp(180px, 16vw, 240px); gap: 9px; padding: 0 2px; }