From 924fccf33922f4d00e2c5bff004eb31344d58ddb Mon Sep 17 00:00:00 2001 From: Pablo Date: Wed, 4 Nov 2026 20:13:16 +0100 Subject: [PATCH] =?UTF-8?q?fix:=20correcciones=20menores=20en=20juego=20y?= =?UTF-8?q?=20l=C3=B3gica=20de=20candidatas=20(#22)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - pickCandidates: si una receta tiene exactamente los ingredientes matcheados, no se propone "La vuestra (con todo)" (sería el mismo plato) y su hueco lo ocupa otra receta. Tests nuevos y la comprobación con datos reales ahora verifica la regla en ambos sentidos. - Nombres: los guardados se filtran (solo textos no vacíos), se recortan a maxPlayers y se completan hasta minPlayers; un localStorage corrupto o bloqueado ya no impide arrancar. Al empezar, un nombre en blanco pasa a "Jugador N". - Swipe: handler de pointercancel para que la carta vuelva a su sitio y el arrastre no quede enganchado. - PROJECT.md §5: la ronda 1 usa shuffle, no buildBalancedPool; regla nueva de la receta personalizada. El escape de emojis con esc() ya quedó resuelto en #4. Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 6 ++++++ PROJECT.md | 13 +++++++------ js/app.js | 41 ++++++++++++++++++++++++++++++++++------- js/shared.js | 18 ++++++++++++++---- tests/shared.test.mjs | 42 +++++++++++++++++++++++++++++++++++++----- 5 files changed, 98 insertions(+), 22 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 53dd200..28e5334 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -30,6 +30,12 @@ Formato basado en [Keep a Changelog](https://keepachangelog.com/es-ES/1.1.0/). o con red lenta, arranca desde caché (#5). ### Corregido +- Correcciones menores (#22): la ronda 3 ya no propone "La vuestra (con + todo)" cuando una receta tiene exactamente esos ingredientes; los nombres + vacíos pasan a "Jugador N" y los guardados se recortan a `maxPlayers` + (y un `localStorage` corrupto ya no impide arrancar); si el navegador + cancela el gesto de arrastre (`pointercancel`), la carta vuelve a su sitio + sin quedarse enganchada. `PROJECT.md` §5 describía mal la ronda 1. - Admin: el borrador local ya no oculta para siempre los cambios de `/data`. Al abrir el admin se compara cada fichero con `/data`: lo que no has editado se actualiza solo y, si hay conflicto, un aviso permite usar la diff --git a/PROJECT.md b/PROJECT.md index d575365..889f4e3 100644 --- a/PROJECT.md +++ b/PROJECT.md @@ -133,9 +133,9 @@ tipo. - **`buildBalancedPool(ingredients, config)`**: agrupa por `cat`, muestrea hasta `categoryCaps[cat]` de cada grupo (barajado), concatena y recorta a - `ingredientPoolSize`. Se usa igual en ronda 1 (con `dishTypes` como - "ingredientes" sin balanceo real, ya que no suele haber muchos tipos) y en - ronda 2. + `ingredientPoolSize`. Se usa en la ronda 2. La ronda 1 no lo usa: baraja + todos los tipos de `dish-types.json` con `shuffle` (limitar cuántos se + enseñan es la issue de `dishTypeCandidateMax`). - **Match**: intersección de los ids marcados "sí" por todos los jugadores, en cualquier ronda. - **`resolveDishType(matchedTypes)`**: si hay más de un tipo de cena @@ -145,9 +145,10 @@ tipo. `overlap` = nº de sus ingredientes que están en el match de ronda 2; `extra` = resto. Se ordenan por overlap desc, extra asc; se filtran las que tengan `overlap >= candidateMinOverlap` (si hay menos de 2 así, se - relaja a `overlap >= 1`). Se añade siempre una receta "personalizada" con - exactamente los ingredientes matcheados, como comodín. Se recorta a - `candidateMax`. + relaja a `overlap >= 1`). Se añade primero una receta "personalizada" con + exactamente los ingredientes matcheados, como comodín, salvo que ya exista + una receta con esos mismos ingredientes (sería el mismo plato repetido); en + ese caso su hueco lo ocupa otra receta. Se recorta a `candidateMax`. ## 6. Panel de administración (`admin.html`) diff --git a/js/app.js b/js/app.js index fa9c496..a27839e 100644 --- a/js/app.js +++ b/js/app.js @@ -35,13 +35,14 @@ async function init() { dishTypes = loaded.dishTypes; gameConfig = loaded.gameConfig; if (!dishTypes.length) throw new Error("No hay tipos de cena configurados en data/dish-types.json"); - const saved = JSON.parse(localStorage.getItem("dinnerMatchNames") || "null"); - if (saved && saved.length >= gameConfig.minPlayers) { - state.names = saved; - state.numPlayers = saved.length; + const saved = readSavedNames(); + if (saved.length >= gameConfig.minPlayers) { + // Recortado a maxPlayers: puede haber bajado desde la última partida. + state.names = saved.slice(0, gameConfig.maxPlayers); + state.numPlayers = state.names.length; } else { state.numPlayers = Math.max(gameConfig.minPlayers, Math.min(3, gameConfig.maxPlayers)); - state.names = Array.from({ length: state.numPlayers }, (_, i) => `Jugador ${i + 1}`); + state.names = Array.from({ length: state.numPlayers }, (_, i) => saved[i] || defaultName(i)); } state.stage = "setup"; } catch (e) { @@ -62,17 +63,35 @@ function showError(title, detail, retry) { render(); } +const NAMES_KEY = "dinnerMatchNames"; +const defaultName = (i) => `Jugador ${i + 1}`; + +// Nombres de la última partida. Tolera localStorage corrupto o bloqueado +// (no debe impedir arrancar) y descarta lo que no sean textos no vacíos. +function readSavedNames() { + try { + const saved = JSON.parse(localStorage.getItem(NAMES_KEY) || "[]"); + return Array.isArray(saved) + ? saved.filter((n) => typeof n === "string").map((n) => n.trim().slice(0, 16)).filter(Boolean) + : []; + } catch { + return []; + } +} + function setNumPlayersClamped(n) { const c = Math.max(gameConfig.minPlayers, Math.min(gameConfig.maxPlayers, n)); state.numPlayers = c; - while (state.names.length < c) state.names.push(`Jugador ${state.names.length + 1}`); + while (state.names.length < c) state.names.push(defaultName(state.names.length)); state.names = state.names.slice(0, c); render(); announce(`${c} jugadores`); } function startRound1() { - localStorage.setItem("dinnerMatchNames", JSON.stringify(state.names)); + // Un nombre vacío (o solo espacios) pasa a "Jugador N" en vez de "Turno de ". + state.names = state.names.map((n, i) => n.trim() || defaultName(i)); + try { localStorage.setItem(NAMES_KEY, JSON.stringify(state.names)); } catch { /* modo privado, sin cuota… */ } state.round = 1; state.deck = shuffle(dishTypes); state.likesByPlayer = Array.from({ length: state.numPlayers }, () => []); @@ -192,6 +211,14 @@ document.addEventListener("pointerup", () => { updateCardTransform(); } }); +// El navegador cancela el gesto (scroll del sistema, llamada entrante, otro +// dedo…): la carta vuelve a su sitio sin votar y el arrastre no queda colgado. +document.addEventListener("pointercancel", () => { + if (!state.dragging) return; + state.dragging = false; + state.dragX = 0; + updateCardTransform(); +}); // ---- Render pieces ---- // Accesibilidad: diff --git a/js/shared.js b/js/shared.js index f10000a..7489cc1 100644 --- a/js/shared.js +++ b/js/shared.js @@ -86,8 +86,9 @@ export function buildBalancedPool(ingredients, config) { /** * Dado el conjunto de ids matcheados en la ronda anterior, propone recetas * candidatas: prioriza mayor solapamiento y menos ingredientes "extra" no - * matcheados, y siempre añade una receta personalizada con exactamente los - * ingredientes matcheados. + * matcheados, y añade primero una receta personalizada con exactamente los + * ingredientes matcheados (salvo que ya exista una receta con esos mismos + * ingredientes). */ export function pickCandidates(matchedIds, recipes, config) { const matchedSet = new Set(matchedIds); @@ -103,8 +104,17 @@ export function pickCandidates(matchedIds, recipes, config) { .filter((r) => r.overlap >= 1); scored.sort((a, b) => b.overlap - a.overlap || a.extra - b.extra); - let top = scored.filter((r) => r.overlap >= minOverlap).slice(0, max - 1); - if (top.length < 2) top = scored.slice(0, max - 1); + // Si una receta tiene exactamente los ingredientes matcheados, la + // personalizada sería el mismo plato repetido: se omite y su hueco lo + // ocupa otra receta. (Esa receta siempre queda primera: overlap máximo y + // extra 0, así que nunca se pierde en el recorte.) + const sameAsCustom = (r) => r.extra === 0 && new Set(r.ingredients).size === matchedSet.size; + const withCustom = !scored.some(sameAsCustom); + const slots = withCustom ? max - 1 : max; + + let top = scored.filter((r) => r.overlap >= minOverlap).slice(0, slots); + if (top.length < 2) top = scored.slice(0, slots); + if (!withCustom) return top; const custom = { id: "custom", name: "La vuestra (con todo)", ingredients: [...matchedSet], custom: true }; const merged = [custom, ...top].filter((r, i, arr) => arr.findIndex((x) => x.id === r.id) === i); diff --git a/tests/shared.test.mjs b/tests/shared.test.mjs index 58f20a3..1b33024 100644 --- a/tests/shared.test.mjs +++ b/tests/shared.test.mjs @@ -131,9 +131,10 @@ describe("pickCandidates", () => { }); test("caso normal: personalizada primero, luego por overlap desc y extra asc", () => { - const out = pickCandidates(["a", "b", "c"], recipes, config); + // "z" hace que ninguna receta coincida exactamente con lo matcheado. + const out = pickCandidates(["a", "b", "c", "z"], recipes, config); assert.equal(out[0].id, "custom"); - assert.deepEqual(out[0].ingredients.sort(), ["a", "b", "c"]); + assert.deepEqual(out[0].ingredients.sort(), ["a", "b", "c", "z"]); // r1 (overlap 1) queda fuera porque hay >= 2 recetas con overlap >= minOverlap. assert.deepEqual(ids(out.slice(1)), ["r3", "r4", "r2b", "r2"]); for (const r of out.slice(1)) { @@ -148,10 +149,34 @@ describe("pickCandidates", () => { }); test("recorta a candidateMax contando la personalizada", () => { - const out = pickCandidates(["a", "b", "c"], recipes, { candidateMax: 3, candidateMinOverlap: 2 }); + const out = pickCandidates(["a", "b", "c", "z"], recipes, { candidateMax: 3, candidateMinOverlap: 2 }); assert.deepEqual(ids(out), ["custom", "r3", "r4"]); }); + test("si una receta coincide exactamente con lo matcheado, no se propone la personalizada", () => { + // r3 = [a, b, c]: la personalizada sería el mismo plato. + const out = pickCandidates(["a", "b", "c"], recipes, config); + assert.ok(!ids(out).includes("custom")); + assert.deepEqual(ids(out), ["r3", "r4", "r2b", "r2"]); + }); + + test("sin personalizada, su hueco lo ocupa otra receta (candidateMax completo)", () => { + const out = pickCandidates(["a", "b", "c"], recipes, { candidateMax: 3, candidateMinOverlap: 2 }); + assert.deepEqual(ids(out), ["r3", "r4", "r2b"]); + }); + + test("la coincidencia exacta no depende del orden ni de repetidos en el match", () => { + for (const m of [["c", "a", "b"], ["b", "b", "a", "c"]]) { + assert.equal(pickCandidates(m, recipes, config)[0].id, "r3"); + } + }); + + test("una receta que contiene todo lo matcheado y algo más no cuenta como idéntica", () => { + // r4 = [a, b, c, d] ⊃ [a, b, d]? No: con [a, b, d] r4 tiene extra 1 (c). + const out = pickCandidates(["a", "b", "d"], recipes, config); + assert.equal(out[0].id, "custom"); + }); + test("si hay menos de 2 recetas con overlap >= minOverlap, relaja a overlap >= 1", () => { // Con ["a", "x"]: overlap 2 → r2, r1; overlap 1 → r4, r3, r2b, r0... pero // con minOverlap 3 ninguna llega, así que se relaja. @@ -197,8 +222,15 @@ describe("pickCandidates", () => { if (matched.length === 0) matched.push(pool[0].id); const out = pickCandidates(matched, t.recipes, t.config); assert.ok(out.length >= 1 && out.length <= t.config.candidateMax); - assert.equal(out[0].id, "custom"); - for (const c of out.slice(1)) { + const set = new Set(matched); + const identical = t.recipes.find((rc) => rc.ingredients.length === set.size && rc.ingredients.every((i) => set.has(i))); + if (identical) { + assert.ok(!ids(out).includes("custom"), "propone la personalizada habiendo una receta idéntica"); + assert.equal(out[0].id, identical.id); + } else { + assert.equal(out[0].id, "custom"); + } + for (const c of out.filter((x) => !x.custom)) { assert.ok(c.overlap >= 1); assert.ok(c.ingredients.every((id) => known.has(id)), `${c.id} referencia un ingrediente inexistente`); }