/* Entraînement syllabique progressif — drill LIBRE (ROADMAP dictée, PEDAGOGIE §3).
Le piège central du coréen oral : 사람은 s'entend [사라믄] (liaison du batchim).
Flux par item : écouter -> compter les syllabes -> reconstruire ce qui est
ÉCRIT parmi des tuiles qui contiennent aussi la forme ENTENDUE. Se tromper en
écrivant ce qu'on entend N'EST PAS une faute aléatoire : c'est LA confusion,
et le feedback la nomme. Aucun effet SRS. */
const ST_STATS_KEY = "syllableTrainerStats";
const ST_RUN_LENGTH = 10;
const ST_RETRY_DELAY = 3;
const ST_LIAISON_PARTICLES = ["은", "이", "을"];
function stShuffle(list, seed) {
const out = list.slice();
let s = seed >>> 0;
for (let i = out.length - 1; i > 0; i--) {
s = (s * 1103515245 + 12345) & 0x7fffffff;
const j = s % (i + 1);
const tmp = out[i]; out[i] = out[j]; out[j] = tmp;
}
return out;
}
/* Construit le vivier d'items depuis vocab_freq : mots réels 2-3 syllabes.
- liaison : mot à batchim + particule vocalique -> la forme entendue change ;
- plain : mot où rien ne bouge (contrôle, évite le réflexe « ça change toujours »). */
function stBuildPool(vocabItems) {
const S = window.LangSyllables;
const liaison = [];
const plain = [];
(vocabItems || []).forEach((item, index) => {
const kr = String(item.kr || "").trim();
if (!/^[가-힣]{2,3}$/.test(kr)) return;
const particle = ST_LIAISON_PARTICLES[index % ST_LIAISON_PARTICLES.length];
const eojeol = kr + particle;
const sp = S.spoken(eojeol);
if (sp.supported && sp.changed) {
liaison.push({ text: eojeol, base: kr, fr: item.fr || "", spoken: sp, kind: "liaison" });
return;
}
const alone = S.spoken(kr);
if (alone.supported && !alone.changed) {
plain.push({ text: kr, base: kr, fr: item.fr || "", spoken: alone, kind: "plain" });
}
});
return { liaison, plain };
}
function stBuildRun(pool, seed) {
const nLiaison = Math.min(6, pool.liaison.length);
const nPlain = Math.min(ST_RUN_LENGTH - nLiaison, pool.plain.length);
const picks = stShuffle(pool.liaison, seed).slice(0, nLiaison)
.concat(stShuffle(pool.plain, seed + 7).slice(0, nPlain));
return stShuffle(picks, seed + 13).map((item, index) => {
const written = item.spoken.written;
const distractors = item.spoken.heard.filter((syl, k) => syl !== written[k]);
const tiles = stShuffle(
written.concat(distractors).map((syl, k) => ({ id: `t${index}_${k}`, syl })),
seed + index * 31 + 3
);
return Object.assign({}, item, { tiles });
});
}
function stSpeak(text, rate) {
if (window.LangAudio) window.LangAudio.speak(text, { rate: rate || 0.9 });
}
function stBumpStats(kind, correct) {
const store = window.LangStore;
if (!store || !store.get) return;
const stats = store.get(ST_STATS_KEY, {}) || {};
const entry = stats[kind] || { attempts: 0, correct: 0 };
entry.attempts += 1;
if (correct) entry.correct += 1;
stats[kind] = entry;
store.set(ST_STATS_KEY, stats);
}
function SyllableTrainer() {
const [loading, setLoading] = useState(true);
const [error, setError] = useState("");
const [pool, setPool] = useState(null);
const [run, setRun] = useState(null); // {queue, idx, correct, total, missQueue}
const [step, setStep] = useState("listen"); // listen | count | build
const [countPick, setCountPick] = useState(null);
const [assembled, setAssembled] = useState([]); // tile ids
const [checked, setChecked] = useState(null); // {correct, heardTrap}
useEffect(() => {
let alive = true;
if (!window.LangData || !window.LangData.loadVocabFreq || !window.LangSyllables) {
setLoading(false);
setError("Données ou moteur syllabique indisponibles.");
return () => { alive = false; };
}
window.LangData.loadVocabFreq()
.then(payload => {
if (!alive) return;
const items = Array.isArray(payload.items) ? payload.items : [];
setPool(stBuildPool(items.slice(0, 600))); // noyau le plus fréquent
})
.catch(() => { if (alive) setError("Impossible de charger le vocabulaire fréquent."); })
.finally(() => { if (alive) setLoading(false); });
return () => { alive = false; if (window.LangAudio) window.LangAudio.stop(); };
}, []);
const resetItem = () => { setStep("listen"); setCountPick(null); setAssembled([]); setChecked(null); };
const start = () => {
if (!pool) return;
setRun({ queue: stBuildRun(pool, Date.now() & 0x7fffffff), idx: 0, correct: 0, total: 0, missQueue: [] });
resetItem();
};
if (loading) return
Chargement du vivier syllabique…
;
if (error) return ;
if (!run) {
const nL = pool ? pool.liaison.length : 0;
return (
Oreille syllabique — entendu vs écritlibre · sans effet SRS
À l'oral, la consonne finale se lie à la voyelle suivante : 사람은 s'entend
« 사라믄 ». Ici on écoute, on découpe, puis on reconstruit ce qui est
écrit — les tuiles pièges viennent de ce qu'on entend.
C'est l'étape entre les micro-contrastes et la dictée.
Commencer · {ST_RUN_LENGTH} items{nL} mots à liaison dans le noyau fréquent
2 · découperCombien de syllabes ?
{[2, 3, 4].map(n => (
))}
{countPick != null && countPick !== written.length && Réécoute en lent : chaque temps est une syllabe.}
)}
{step === "build" && (
3 · reconstruireAssemble ce qui est écrit — pas forcément ce que tu entends.
{assembled.length === 0 && Touche les tuiles dans l'ordre…}
{assembled.map(id => {
const t = item.tiles.find(x => x.id === id);
return ;
})}
{checked.correct ? "Exact." : checked.heardTrap ? "Tu as écrit ce que tu ENTENDS — c'est le piège visé." : "Pas tout à fait."}
On entend[{heardText}]On écrit{writtenText}
{item.spoken.links.length > 0 && (
{item.spoken.links.map(l => l.batchim === "ㅎ"
? `Le ㅎ de « ${written[l.from]} » ne s'entend pas devant une voyelle.`
: `Le ${l.batchim} final de « ${written[l.from]} » se lie à la syllabe suivante.`).join(" ")}
)}