8e29953a95
All checks were successful
Deploy to production / deploy (push) Successful in 2m52s
- Introduced a new lesson titled "Zeit & Datum" with multiple exercises focusing on recognizing and using key time-related vocabulary in Bisaya. - Added various exercise types including multiple-choice, gap-fill, and transformation tasks to enhance learner engagement and understanding of temporal expressions. - Updated didactics to include learning goals, core patterns, grammar focus, speaking prompts, and practical tasks related to time markers and simple date questions.
4928 lines
174 KiB
JavaScript
4928 lines
174 KiB
JavaScript
#!/usr/bin/env node
|
||
/**
|
||
* Script zum Erstellen von sprachspezifischem Content für Bisaya-Kurse
|
||
*
|
||
* Verwendung:
|
||
* node backend/scripts/create-bisaya-course-content.js
|
||
*
|
||
* Erstellt Grammatik-Übungen für alle Lektionen in Bisaya-Kursen basierend auf dem Thema der Lektion.
|
||
*/
|
||
|
||
import { sequelize } from '../utils/sequelize.js';
|
||
import VocabCourseLesson from '../models/community/vocab_course_lesson.js';
|
||
import VocabGrammarExercise from '../models/community/vocab_grammar_exercise.js';
|
||
import VocabCourse from '../models/community/vocab_course.js';
|
||
import User from '../models/community/user.js';
|
||
import { BISAYA_PHASE3_DIDACTICS } from './bisaya-course-phase3-extension.js';
|
||
import { BISAYA_PHASE4_DIDACTICS } from './bisaya-course-phase4-extension.js';
|
||
import { BISAYA_PHASE5_DIDACTICS } from './bisaya-course-phase5-extension.js';
|
||
|
||
function withTypeName(exerciseTypeName, exercise) {
|
||
return {
|
||
...exercise,
|
||
exerciseTypeName
|
||
};
|
||
}
|
||
|
||
const GENERATED_BISAYA_DIDACTICS = {
|
||
...BISAYA_PHASE3_DIDACTICS,
|
||
...BISAYA_PHASE4_DIDACTICS,
|
||
...BISAYA_PHASE5_DIDACTICS
|
||
};
|
||
|
||
function normalizeText(value) {
|
||
return String(value || '')
|
||
.trim()
|
||
.replace(/\s+/g, ' ');
|
||
}
|
||
|
||
function countWords(value) {
|
||
return normalizeText(value).split(' ').filter(Boolean).length;
|
||
}
|
||
|
||
function collectExerciseAuditWarnings(lessonTitle, exerciseData, exerciseNumber) {
|
||
const warnings = [];
|
||
const questionData = exerciseData?.questionData || {};
|
||
const answerData = exerciseData?.answerData || {};
|
||
if (questionData.type !== 'gap_fill') return warnings;
|
||
|
||
const text = String(questionData.text || '');
|
||
const answers = Array.isArray(answerData.answers) ? answerData.answers : [];
|
||
if (!text || !answers.length) return warnings;
|
||
|
||
const hints = [];
|
||
const hintRegex = /\(([^)]+)\)/g;
|
||
let match = hintRegex.exec(text);
|
||
while (match) {
|
||
hints.push(normalizeText(match[1]));
|
||
match = hintRegex.exec(text);
|
||
}
|
||
|
||
for (let i = 0; i < Math.min(answers.length, hints.length); i += 1) {
|
||
const answer = normalizeText(answers[i]);
|
||
const hint = hints[i];
|
||
if (!answer || !hint) continue;
|
||
const answerWords = countWords(answer);
|
||
const hintWords = countWords(hint);
|
||
if (answerWords <= 2 && hintWords >= 4) {
|
||
warnings.push(
|
||
`[${lessonTitle} #${exerciseNumber}] Gap-Fill-Hinweis wirkt zu lang für eine Kurzantwort: "${answer}" <-> "${hint}"`
|
||
);
|
||
}
|
||
}
|
||
|
||
return warnings;
|
||
}
|
||
|
||
function buildCorePatternGlossLookup(didactics) {
|
||
const map = new Map();
|
||
const patterns = Array.isArray(didactics?.corePatterns) ? didactics.corePatterns : [];
|
||
patterns.forEach((entry) => {
|
||
const normalized = normalizeCorePatternEntry(entry);
|
||
if (!normalized?.target || !normalized?.gloss) return;
|
||
map.set(normalized.target.toLowerCase(), normalized.gloss);
|
||
});
|
||
return map;
|
||
}
|
||
|
||
function phraseWordCount(value) {
|
||
return countWords(value);
|
||
}
|
||
|
||
function isPhraseLike(value) {
|
||
return phraseWordCount(value) >= 2;
|
||
}
|
||
|
||
function normalizeQuotedPrompt(value) {
|
||
return normalizeText(String(value || '').replace(/[„“"']/g, ''));
|
||
}
|
||
|
||
function firstQuotedContent(value) {
|
||
const text = String(value || '');
|
||
const doubleQuote = text.match(/"([^"]+)"/);
|
||
if (doubleQuote?.[1]) return normalizeText(doubleQuote[1]);
|
||
const deQuote = text.match(/„([^“]+)“/);
|
||
if (deQuote?.[1]) return normalizeText(deQuote[1]);
|
||
const singleQuote = text.match(/'([^']+)'/);
|
||
if (singleQuote?.[1]) return normalizeText(singleQuote[1]);
|
||
return '';
|
||
}
|
||
|
||
function addUniquePattern(out, seen, target, gloss) {
|
||
const t = normalizeText(target);
|
||
const g = normalizeText(gloss);
|
||
if (!t || !g) return;
|
||
if (!isPhraseLike(t)) return;
|
||
const key = `${t.toLowerCase()}|${g.toLowerCase()}`;
|
||
if (seen.has(key)) return;
|
||
seen.add(key);
|
||
out.push({ target: t, gloss: g });
|
||
}
|
||
|
||
function extractPairsFromGapFill(questionData, answerData, out, seen) {
|
||
const text = String(questionData?.text || '');
|
||
const answers = Array.isArray(answerData?.answers) ? answerData.answers : [];
|
||
if (!text || answers.length === 0) return;
|
||
|
||
const hints = [];
|
||
const hintRegex = /\(([^)]+)\)/g;
|
||
let match = hintRegex.exec(text);
|
||
while (match) {
|
||
hints.push(normalizeText(match[1]));
|
||
match = hintRegex.exec(text);
|
||
}
|
||
|
||
for (let i = 0; i < Math.min(answers.length, hints.length); i += 1) {
|
||
addUniquePattern(out, seen, answers[i], hints[i]);
|
||
}
|
||
}
|
||
|
||
function extractPairsFromTransformation(questionData, answerData, out, seen) {
|
||
const src = normalizeText(questionData?.text || '');
|
||
const trg = normalizeText(answerData?.correct || '');
|
||
if (!src || !trg) return;
|
||
const sourceLanguage = normalizeText(questionData?.sourceLanguage || '').toLowerCase();
|
||
const targetLanguage = normalizeText(questionData?.targetLanguage || '').toLowerCase();
|
||
if (sourceLanguage === 'deutsch' || targetLanguage === 'bisaya') {
|
||
addUniquePattern(out, seen, trg, src);
|
||
return;
|
||
}
|
||
addUniquePattern(out, seen, src, trg);
|
||
}
|
||
|
||
function extractPairsFromMultipleChoice(questionData, answerData, out, seen) {
|
||
const question = normalizeText(questionData?.question || '');
|
||
const options = Array.isArray(questionData?.options) ? questionData.options : [];
|
||
const index = Number(answerData?.correctAnswer);
|
||
const correct = normalizeText(options[index] || '');
|
||
if (!question || !correct) return;
|
||
|
||
const quoted = firstQuotedContent(question);
|
||
const lower = question.toLowerCase();
|
||
if (!quoted) return;
|
||
|
||
if (lower.startsWith('was bedeutet')) {
|
||
addUniquePattern(out, seen, quoted, correct);
|
||
return;
|
||
}
|
||
if (lower.startsWith('wie sagt man')) {
|
||
addUniquePattern(out, seen, correct, normalizeQuotedPrompt(quoted));
|
||
}
|
||
}
|
||
|
||
function deriveLessonCorePatternsFromExercises(exercises) {
|
||
const out = [];
|
||
const seen = new Set();
|
||
(Array.isArray(exercises) ? exercises : []).forEach((exercise) => {
|
||
const questionData = exercise?.questionData || {};
|
||
const answerData = exercise?.answerData || {};
|
||
const type = String(questionData?.type || '');
|
||
if (type === 'gap_fill') {
|
||
extractPairsFromGapFill(questionData, answerData, out, seen);
|
||
} else if (type === 'transformation') {
|
||
extractPairsFromTransformation(questionData, answerData, out, seen);
|
||
} else if (type === 'multiple_choice') {
|
||
extractPairsFromMultipleChoice(questionData, answerData, out, seen);
|
||
}
|
||
});
|
||
return out;
|
||
}
|
||
|
||
function mergeCorePatternsForLesson(didactics, exerciseDerived, minCount = 8) {
|
||
const out = [];
|
||
const seen = new Set();
|
||
const basePatterns = Array.isArray(didactics?.corePatterns) ? didactics.corePatterns : [];
|
||
|
||
basePatterns.forEach((entry) => {
|
||
const normalized = normalizeCorePatternEntry(entry);
|
||
if (!normalized?.target || !normalized?.gloss) return;
|
||
addUniquePattern(out, seen, normalized.target, normalized.gloss);
|
||
});
|
||
exerciseDerived.forEach((entry) => {
|
||
addUniquePattern(out, seen, entry?.target, entry?.gloss);
|
||
});
|
||
|
||
if (out.length >= minCount) return out;
|
||
return out;
|
||
}
|
||
|
||
function normalizeGrammarFocusEntry(entry) {
|
||
if (!entry || typeof entry !== 'object') return null;
|
||
const title = normalizeText(entry.title || '');
|
||
const text = normalizeText(entry.text || '');
|
||
const example = normalizeText(entry.example || '');
|
||
if (!title || !text) return null;
|
||
return { title, text, ...(example ? { example } : {}) };
|
||
}
|
||
|
||
function buildGrammarCurriculumFocus(lesson) {
|
||
const lessonNumber = Number(lesson?.lessonNumber || 0);
|
||
const title = normalizeText(lesson?.title || '').toLowerCase();
|
||
const out = [];
|
||
|
||
if (lessonNumber >= 1 && lessonNumber <= 10) {
|
||
out.push({
|
||
title: 'Kernaussage + Ergänzung',
|
||
text: 'Im Alltag funktionieren kurze Muster am besten: Aussage zuerst, dann Ort/Zeit/Detail.',
|
||
example: 'Naa ko sa balay. / Moadto ko unya.'
|
||
});
|
||
}
|
||
|
||
if (lessonNumber >= 11 && lessonNumber <= 20) {
|
||
out.push({
|
||
title: 'Präsens, Vergangenheit, Zukunft',
|
||
text: 'In diesem Kurs arbeitest du mit klaren Zeitmarkern: Gegenwart über Kontext oder nag-/ga-, Vergangenheit oft mit ni-, Zukunft mit mo-.',
|
||
example: 'Nagkaon ko. / Ni-kaon ko. / Mo-kaon ko.'
|
||
});
|
||
}
|
||
|
||
if (title.includes('zeitformen')) {
|
||
out.push(
|
||
{
|
||
title: 'Vergangenheit mit ni-',
|
||
text: 'ni- markiert häufig abgeschlossene Handlungen in der Vergangenheit.',
|
||
example: 'Ni-adto ko. (Ich bin gegangen.)'
|
||
},
|
||
{
|
||
title: 'Zukunft/Absicht mit mo-',
|
||
text: 'mo- markiert häufig Zukünftiges oder eine geplante Handlung.',
|
||
example: 'Mo-adto ko. (Ich werde gehen.)'
|
||
}
|
||
);
|
||
}
|
||
|
||
if (lessonNumber >= 21) {
|
||
out.push({
|
||
title: 'Aspekt statt starrer Zeiten',
|
||
text: 'Bisaya nutzt im Alltag oft Aspektmarker und Kontext statt fixer Tempusformen. Zeitwörter wie karon, ganiha, ugma helfen bei der Einordnung.',
|
||
example: 'Niadto ko ganiha. / Moadto ko ugma.'
|
||
});
|
||
}
|
||
|
||
return out.map((entry) => normalizeGrammarFocusEntry(entry)).filter(Boolean);
|
||
}
|
||
|
||
function mergeGrammarFocusForLesson(existingFocus, curriculumFocus) {
|
||
const out = [];
|
||
const seen = new Set();
|
||
const pushUnique = (entry) => {
|
||
const normalized = normalizeGrammarFocusEntry(entry);
|
||
if (!normalized) return;
|
||
const key = `${normalized.title.toLowerCase()}|${normalized.text.toLowerCase()}`;
|
||
if (seen.has(key)) return;
|
||
seen.add(key);
|
||
out.push(normalized);
|
||
};
|
||
(Array.isArray(existingFocus) ? existingFocus : []).forEach(pushUnique);
|
||
(Array.isArray(curriculumFocus) ? curriculumFocus : []).forEach(pushUnique);
|
||
return out;
|
||
}
|
||
|
||
function buildZeitformenDrills(lessonTitle) {
|
||
return [
|
||
{
|
||
exerciseTypeName: 'transformation',
|
||
title: `${lessonTitle}: Vergangenheit bilden`,
|
||
instruction: 'Übersetze den Satz ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Ich bin zum Markt gegangen.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Ni-adto ko sa merkado.',
|
||
alternatives: ['Niadto ko sa merkado.', 'Niadto ko sa merkado.']
|
||
},
|
||
explanation: 'Vergangenheit wird hier mit ni- markiert.'
|
||
},
|
||
{
|
||
exerciseTypeName: 'transformation',
|
||
title: `${lessonTitle}: Zukunft bilden`,
|
||
instruction: 'Übersetze den Satz ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Ich werde morgen nach Hause gehen.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Mo-adto ko sa balay ugma.',
|
||
alternatives: ['Moadto ko sa balay ugma.', 'Mo uli ko ugma.']
|
||
},
|
||
explanation: 'Zukünftiges wird hier mit mo- plus Zeitwort (ugma) markiert.'
|
||
}
|
||
];
|
||
}
|
||
|
||
function sanitizeGapFillHintText(lessonTitle, text, answers, glossLookup) {
|
||
const source = String(text || '');
|
||
const normalizedAnswers = Array.isArray(answers)
|
||
? answers.map((answer) => normalizeText(answer))
|
||
: [];
|
||
if (!source || normalizedAnswers.length === 0) {
|
||
return { text: source, fixes: [], warnings: [] };
|
||
}
|
||
|
||
const hintRegex = /\(([^)]+)\)/g;
|
||
let hintIndex = 0;
|
||
const fixes = [];
|
||
const warnings = [];
|
||
const rebuilt = source.replace(hintRegex, (full, inner) => {
|
||
const answer = normalizedAnswers[hintIndex] || '';
|
||
const hint = normalizeText(inner);
|
||
hintIndex += 1;
|
||
if (!answer || !hint) return full;
|
||
|
||
const answerWords = countWords(answer);
|
||
const hintWords = countWords(hint);
|
||
if (!(answerWords <= 2 && hintWords >= 4)) {
|
||
return full;
|
||
}
|
||
|
||
const mappedGloss = normalizeText(glossLookup.get(answer.toLowerCase()) || '');
|
||
if (mappedGloss && countWords(mappedGloss) <= 3) {
|
||
fixes.push(`[${lessonTitle}] "${answer}": "${hint}" -> "${mappedGloss}"`);
|
||
return `(${mappedGloss})`;
|
||
}
|
||
|
||
warnings.push(
|
||
`[${lessonTitle}] Keine sichere Gloss für "${answer}" gefunden; langer Hinweis bleibt: "${hint}"`
|
||
);
|
||
return full;
|
||
});
|
||
|
||
return { text: rebuilt, fixes, warnings };
|
||
}
|
||
|
||
function sanitizeExerciseForConsistency(lesson, exerciseData, didactics) {
|
||
const exercise = { ...exerciseData };
|
||
const questionData = { ...(exerciseData?.questionData || {}) };
|
||
const answerData = { ...(exerciseData?.answerData || {}) };
|
||
const fixes = [];
|
||
const warnings = [];
|
||
|
||
if (questionData.type === 'gap_fill') {
|
||
const glossLookup = buildCorePatternGlossLookup(didactics);
|
||
const sanitized = sanitizeGapFillHintText(
|
||
lesson.title,
|
||
questionData.text,
|
||
Array.isArray(answerData.answers) ? answerData.answers : [],
|
||
glossLookup
|
||
);
|
||
if (sanitized.text !== questionData.text) {
|
||
questionData.text = sanitized.text;
|
||
fixes.push(...sanitized.fixes);
|
||
}
|
||
warnings.push(...sanitized.warnings);
|
||
}
|
||
|
||
exercise.questionData = questionData;
|
||
exercise.answerData = answerData;
|
||
return { exercise, fixes, warnings };
|
||
}
|
||
|
||
function normalizeCorePatternEntry(entry) {
|
||
if (entry === null || entry === undefined || entry === '') {
|
||
return null;
|
||
}
|
||
if (typeof entry === 'object' && !Array.isArray(entry)) {
|
||
const target = normalizeText(entry.target ?? entry.ceb ?? entry.phrase ?? '');
|
||
const gloss = normalizeText(entry.gloss ?? entry.de ?? entry.translation ?? '');
|
||
if (!target) return null;
|
||
return { target, gloss };
|
||
}
|
||
const s = normalizeText(entry);
|
||
if (!s) return null;
|
||
const pipe = s.indexOf('|');
|
||
if (pipe !== -1) {
|
||
const target = normalizeText(s.slice(0, pipe));
|
||
const gloss = normalizeText(s.slice(pipe + 1));
|
||
if (!target) return null;
|
||
return { target, gloss };
|
||
}
|
||
return { target: s, gloss: '' };
|
||
}
|
||
|
||
function corePatternTarget(entry) {
|
||
const n = normalizeCorePatternEntry(entry);
|
||
return n ? n.target : '';
|
||
}
|
||
|
||
const GENERIC_DISTRACTOR_PATTERNS = Array.from(new Set(
|
||
Object.values(GENERATED_BISAYA_DIDACTICS)
|
||
.flatMap((entry) => Array.isArray(entry?.corePatterns) ? entry.corePatterns : [])
|
||
.map((pattern) => corePatternTarget(pattern))
|
||
.filter(Boolean)
|
||
)).slice(0, 200);
|
||
|
||
function simpleHash(value) {
|
||
return Array.from(String(value || '')).reduce((sum, char) => sum + char.charCodeAt(0), 0);
|
||
}
|
||
|
||
function rotateArray(values, offset) {
|
||
if (!Array.isArray(values) || values.length === 0) return [];
|
||
const normalizedOffset = ((offset % values.length) + values.length) % values.length;
|
||
return values.slice(normalizedOffset).concat(values.slice(0, normalizedOffset));
|
||
}
|
||
|
||
function getLessonDidactics(lesson) {
|
||
const staticDidactics = GENERATED_BISAYA_DIDACTICS[lesson.title] || {};
|
||
const learningGoals = Array.isArray(lesson.learningGoals) ? lesson.learningGoals : (staticDidactics.learningGoals || []);
|
||
const corePatterns = Array.isArray(lesson.corePatterns) ? lesson.corePatterns : (staticDidactics.corePatterns || []);
|
||
const grammarFocus = Array.isArray(lesson.grammarFocus) ? lesson.grammarFocus : (staticDidactics.grammarFocus || []);
|
||
const speakingPrompts = Array.isArray(lesson.speakingPrompts) ? lesson.speakingPrompts : (staticDidactics.speakingPrompts || []);
|
||
const practicalTasks = Array.isArray(lesson.practicalTasks) ? lesson.practicalTasks : (staticDidactics.practicalTasks || []);
|
||
|
||
return {
|
||
learningGoals,
|
||
corePatterns: corePatterns
|
||
.map((entry) => normalizeCorePatternEntry(entry))
|
||
.filter(Boolean),
|
||
grammarFocus,
|
||
speakingPrompts,
|
||
practicalTasks
|
||
};
|
||
}
|
||
|
||
function getScenarioPrompt(lesson, didactics) {
|
||
const speakingPrompt = Array.isArray(didactics.speakingPrompts) ? didactics.speakingPrompts[0] : null;
|
||
const practicalTask = Array.isArray(didactics.practicalTasks) ? didactics.practicalTasks[0] : null;
|
||
|
||
if (speakingPrompt?.prompt) return speakingPrompt.prompt;
|
||
if (practicalTask?.text) return practicalTask.text;
|
||
if (lesson.description) return lesson.description;
|
||
return `Reagiere passend in einer Situation aus der Lektion "${lesson.title}".`;
|
||
}
|
||
|
||
function getChoiceQuestion(lesson, didactics) {
|
||
const scenarioPrompt = getScenarioPrompt(lesson, didactics);
|
||
|
||
switch (lesson.lessonType) {
|
||
case 'conversation':
|
||
return `${scenarioPrompt} Welche Bisaya-Formulierung passt am besten?`;
|
||
case 'grammar':
|
||
return `Welche Formulierung passt als kurze Alltagsstruktur zu "${lesson.title}"?`;
|
||
case 'review':
|
||
return `Welche Formulierung solltest du aus "${lesson.title}" sicher wiedererkennen?`;
|
||
case 'culture':
|
||
return `Welcher Ausdruck gehört am ehesten zum kulturellen Schwerpunkt "${lesson.title}"?`;
|
||
case 'vocab':
|
||
default:
|
||
return `Welcher Ausdruck gehört thematisch zu "${lesson.title}"?`;
|
||
}
|
||
}
|
||
|
||
function pickDistractors(pattern, allPatterns, count) {
|
||
return allPatterns
|
||
.filter((entry) => entry !== pattern)
|
||
.slice(0, count);
|
||
}
|
||
|
||
function buildChoiceExercise(lesson, didactics, pattern, allPatterns, variant = 0) {
|
||
const distractors = pickDistractors(pattern, allPatterns, 3);
|
||
if (distractors.length < 3) return null;
|
||
|
||
const seed = simpleHash(`${lesson.title}:${pattern}:${variant}`);
|
||
const options = rotateArray([pattern, ...distractors], seed % 4);
|
||
const correctAnswer = options.indexOf(pattern);
|
||
|
||
return {
|
||
exerciseTypeId: 2,
|
||
title: `${lesson.title}: Passende Formulierung wählen`,
|
||
instruction: 'Wähle die natürlichste Formulierung für die Situation oder den Schwerpunkt der Lektion.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: getChoiceQuestion(lesson, didactics),
|
||
options
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer
|
||
},
|
||
explanation: `"${pattern}" ist ein zentrales Muster dieser Lektion.`
|
||
};
|
||
}
|
||
|
||
function pickGapTarget(pattern) {
|
||
const tokens = normalizeText(pattern)
|
||
.split(' ')
|
||
.map((token) => token.trim())
|
||
.filter(Boolean);
|
||
|
||
const candidates = tokens
|
||
.map((token, index) => ({ token, index, score: token.replace(/[.,?!]/g, '').length }))
|
||
.filter(({ token }) => token.replace(/[.,?!]/g, '').length >= 4);
|
||
|
||
if (candidates.length === 0) {
|
||
return null;
|
||
}
|
||
|
||
candidates.sort((left, right) => right.score - left.score);
|
||
return candidates[0];
|
||
}
|
||
|
||
function buildGapExercise(lessonTitle, pattern) {
|
||
const gapTarget = pickGapTarget(pattern);
|
||
if (!gapTarget) return null;
|
||
|
||
const tokens = normalizeText(pattern).split(' ');
|
||
tokens[gapTarget.index] = '{gap}';
|
||
|
||
return {
|
||
exerciseTypeId: 1,
|
||
title: `${lessonTitle}: Muster vervollständigen`,
|
||
instruction: 'Fülle die Lücke mit dem passenden Bisaya-Ausdruck.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: tokens.join(' '),
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: [gapTarget.token.replace(/[.,?!]/g, '')]
|
||
},
|
||
explanation: `Das Kernmuster lautet: "${pattern}".`
|
||
};
|
||
}
|
||
|
||
function buildContextGapExercise(lesson, didactics, pattern) {
|
||
const gapExercise = buildGapExercise(lesson.title, pattern);
|
||
if (!gapExercise) return null;
|
||
|
||
return {
|
||
...gapExercise,
|
||
title: `${lesson.title}: Kernmuster ergänzen`,
|
||
instruction: `Vervollständige die Formulierung passend zur Situation: ${getScenarioPrompt(lesson, didactics)}`
|
||
};
|
||
}
|
||
|
||
function buildSentenceExercise(lessonTitle, pattern) {
|
||
const tokens = normalizeText(pattern)
|
||
.replace(/[?!]/g, '')
|
||
.split(' ')
|
||
.filter(Boolean);
|
||
|
||
if (tokens.length < 2) return null;
|
||
|
||
return {
|
||
exerciseTypeId: 3,
|
||
title: `${lessonTitle}: Satzmuster bauen`,
|
||
instruction: 'Ordne die Wörter zu einem korrekten Bisaya-Satz.',
|
||
questionData: {
|
||
type: 'sentence_building',
|
||
question: `Baue das Kernmuster aus der Lektion "${lessonTitle}".`,
|
||
tokens
|
||
},
|
||
answerData: {
|
||
correct: [normalizeText(pattern)]
|
||
},
|
||
explanation: `Dieses Kernmuster gehört zur Lektion "${lessonTitle}".`
|
||
};
|
||
}
|
||
|
||
function buildTaskSentenceExercise(lesson, didactics, pattern) {
|
||
const sentenceExercise = buildSentenceExercise(lesson.title, pattern);
|
||
if (!sentenceExercise) return null;
|
||
|
||
const practicalTask = Array.isArray(didactics.practicalTasks) ? didactics.practicalTasks[0] : null;
|
||
|
||
return {
|
||
...sentenceExercise,
|
||
title: `${lesson.title}: Satz aus dem Alltag bauen`,
|
||
instruction: practicalTask?.text
|
||
? `Baue die passende Formulierung für diese Aufgabe: ${practicalTask.text}`
|
||
: 'Ordne die Wörter zu einem natürlichen Bisaya-Satz aus dem Alltag.'
|
||
};
|
||
}
|
||
|
||
function buildGrammarFocusCheckExercise(lesson, didactics) {
|
||
const focus = Array.isArray(didactics?.grammarFocus) ? didactics.grammarFocus[0] : null;
|
||
const text = normalizeText(focus?.text || '');
|
||
if (!text) return null;
|
||
const lower = text.toLowerCase();
|
||
|
||
let question = `Welcher Marker passt im Schwerpunkt "${lesson.title}" typischerweise für eine Zukunftsaussage?`;
|
||
let options = ['mo-', 'ni-', 'nag-/ga-', 'ka-'];
|
||
let correctAnswer = 0;
|
||
let explanation = 'Im Grundkurs wird mo- als Marker für Zukunft/Absicht verwendet.';
|
||
|
||
if (lower.includes('vergangen')) {
|
||
question = `Welcher Marker passt im Schwerpunkt "${lesson.title}" typischerweise für eine vergangene Handlung?`;
|
||
options = ['ni-', 'mo-', 'nag-/ga-', 'ka-'];
|
||
correctAnswer = 0;
|
||
explanation = 'Im Grundkurs steht ni- typischerweise für abgeschlossene Vergangenheit.';
|
||
} else if (lower.includes('gegenwart') || lower.includes('laufende')) {
|
||
question = `Welcher Marker passt im Schwerpunkt "${lesson.title}" typischerweise für eine laufende Handlung?`;
|
||
options = ['nag-/ga-', 'ni-', 'mo-', 'ka-'];
|
||
correctAnswer = 0;
|
||
explanation = 'Nag-/ga- markiert im Kurs eine laufende Handlung in der Gegenwart.';
|
||
}
|
||
|
||
return {
|
||
exerciseTypeId: 2,
|
||
title: `${lesson.title}: Grammatikfokus prüfen`,
|
||
instruction: 'Wähle die passendste Antwort.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question,
|
||
options
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer },
|
||
explanation
|
||
};
|
||
}
|
||
|
||
function buildSpeakingExercise(lessonTitle, didactics, fallbackPattern) {
|
||
const speakingPrompt = Array.isArray(didactics.speakingPrompts) ? didactics.speakingPrompts[0] : null;
|
||
const expectedText = normalizeText(speakingPrompt?.cue || fallbackPattern);
|
||
if (!expectedText) return null;
|
||
|
||
const keywords = expectedText
|
||
.toLowerCase()
|
||
.replace(/[.,?!]/g, '')
|
||
.split(' ')
|
||
.filter((token) => token.length >= 4)
|
||
.slice(0, 4);
|
||
|
||
return {
|
||
exerciseTypeId: 8,
|
||
title: `${lessonTitle}: Laut sprechen`,
|
||
instruction: 'Sprich das zentrale Muster oder den Dialog frei nach.',
|
||
questionData: {
|
||
type: 'speaking_from_memory',
|
||
question: speakingPrompt?.prompt || `Sprich ein zentrales Muster aus der Lektion "${lessonTitle}".`,
|
||
expectedText,
|
||
keywords
|
||
},
|
||
answerData: {
|
||
type: 'speaking_from_memory'
|
||
},
|
||
explanation: 'Wichtig sind hier ein flüssiger Abruf und die zentralen Schlüsselwörter.'
|
||
};
|
||
}
|
||
|
||
function buildReviewChoiceExercise(lesson, didactics, pattern, allPatterns) {
|
||
const choiceExercise = buildChoiceExercise(lesson, didactics, pattern, allPatterns, 1);
|
||
if (!choiceExercise) return null;
|
||
|
||
return {
|
||
...choiceExercise,
|
||
title: `${lesson.title}: Sicheren Abruf prüfen`,
|
||
instruction: 'Wähle die Formulierung, die du aus dem aktiven Wiederholungsblock sicher können solltest.'
|
||
};
|
||
}
|
||
|
||
function buildCultureExercise(lesson, didactics, pattern, allPatterns) {
|
||
const distractors = pickDistractors(pattern, allPatterns, 3);
|
||
if (distractors.length < 3) return null;
|
||
|
||
const culturalNote = normalizeText(lesson.culturalNotes || '');
|
||
const options = rotateArray([pattern, ...distractors], simpleHash(`${lesson.title}:culture`) % 4);
|
||
|
||
return {
|
||
exerciseTypeId: 2,
|
||
title: `${lesson.title}: Ausdruck kulturell einordnen`,
|
||
instruction: 'Ordne den Ausdruck dem kulturellen Schwerpunkt der Lektion zu.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: culturalNote
|
||
? `${culturalNote} Welcher Ausdruck passt dazu besonders gut?`
|
||
: `Welcher Ausdruck gehört besonders gut zum Schwerpunkt "${lesson.title}"?`,
|
||
options
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: options.indexOf(pattern)
|
||
},
|
||
explanation: `Der Ausdruck "${pattern}" gehört eng zum kulturellen Schwerpunkt dieser Lektion.`
|
||
};
|
||
}
|
||
|
||
function buildSituationalExercise(lessonTitle, didactics, fallbackPattern) {
|
||
const speakingPrompt = Array.isArray(didactics.speakingPrompts) ? didactics.speakingPrompts[0] : null;
|
||
const modelAnswer = normalizeText(speakingPrompt?.cue || fallbackPattern);
|
||
if (!modelAnswer) return null;
|
||
|
||
const keywords = modelAnswer
|
||
.toLowerCase()
|
||
.replace(/[.,?!]/g, '')
|
||
.split(' ')
|
||
.filter((token) => token.length >= 4)
|
||
.slice(0, 4);
|
||
|
||
return withTypeName('situational_response', {
|
||
title: `${lessonTitle}: Situativ reagieren`,
|
||
instruction: 'Antworte kurz und passend auf die Situation.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: speakingPrompt?.prompt || `Reagiere passend mit einem Ausdruck aus der Lektion "${lessonTitle}".`,
|
||
keywords
|
||
},
|
||
answerData: {
|
||
modelAnswer,
|
||
keywords
|
||
},
|
||
explanation: `Das Kernmuster "${modelAnswer}" passt natürlich zu dieser Situation.`
|
||
});
|
||
}
|
||
|
||
function generateExercisesFromDidactics(lesson) {
|
||
const didactics = getLessonDidactics(lesson);
|
||
const corePatterns = didactics.corePatterns;
|
||
|
||
if (corePatterns.length === 0) {
|
||
return [];
|
||
}
|
||
|
||
const patternA = corePatternTarget(corePatterns[0]);
|
||
const patternB = corePatternTarget(corePatterns[1] || corePatterns[0]);
|
||
const lessonPool = Array.from(new Set([
|
||
...corePatterns.map((p) => corePatternTarget(p)),
|
||
...GENERIC_DISTRACTOR_PATTERNS
|
||
]));
|
||
let generated = [];
|
||
|
||
if (lesson.lessonType === 'conversation') {
|
||
generated = [
|
||
buildChoiceExercise(lesson, didactics, patternA, lessonPool, 0),
|
||
buildContextGapExercise(lesson, didactics, patternA),
|
||
buildTaskSentenceExercise(lesson, didactics, patternB),
|
||
buildSituationalExercise(lesson.title, didactics, patternA),
|
||
buildSpeakingExercise(lesson.title, didactics, patternB)
|
||
];
|
||
} else if (lesson.lessonType === 'grammar') {
|
||
generated = [
|
||
buildChoiceExercise(lesson, didactics, patternA, lessonPool, 0),
|
||
buildChoiceExercise(lesson, didactics, patternB, lessonPool, 1),
|
||
buildContextGapExercise(lesson, didactics, patternA),
|
||
buildTaskSentenceExercise(lesson, didactics, patternB),
|
||
buildGrammarFocusCheckExercise(lesson, didactics),
|
||
buildSpeakingExercise(lesson.title, didactics, patternA)
|
||
];
|
||
if (String(lesson.title || '').toLowerCase().includes('zeitformen')) {
|
||
generated.push(...buildZeitformenDrills(lesson.title));
|
||
}
|
||
} else if (lesson.lessonType === 'review' || lesson.didacticMode === 'intensive_review') {
|
||
generated = [
|
||
buildReviewChoiceExercise(lesson, didactics, patternA, lessonPool),
|
||
buildReviewChoiceExercise(lesson, didactics, patternB, lessonPool),
|
||
buildContextGapExercise(lesson, didactics, patternA),
|
||
buildTaskSentenceExercise(lesson, didactics, patternB),
|
||
buildSituationalExercise(lesson.title, didactics, patternA),
|
||
buildSpeakingExercise(lesson.title, didactics, patternB)
|
||
];
|
||
} else if (lesson.lessonType === 'culture') {
|
||
generated = [
|
||
buildCultureExercise(lesson, didactics, patternA, lessonPool),
|
||
buildContextGapExercise(lesson, didactics, patternA),
|
||
buildSpeakingExercise(lesson.title, didactics, patternB)
|
||
];
|
||
} else {
|
||
generated = [
|
||
buildChoiceExercise(lesson, didactics, patternA, lessonPool, 0),
|
||
buildChoiceExercise(lesson, didactics, patternB, lessonPool, 1),
|
||
buildContextGapExercise(lesson, didactics, patternA),
|
||
buildTaskSentenceExercise(lesson, didactics, patternB)
|
||
];
|
||
}
|
||
|
||
return generated.filter(Boolean);
|
||
}
|
||
|
||
// Bisaya-spezifische Übungen basierend auf Lektionsthemen
|
||
const BISAYA_EXERCISES = {
|
||
// Lektion 1: Begrüßungen & Höflichkeit
|
||
'Begrüßungen & Höflichkeit': [
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Wie geht es dir?" auf Bisaya?',
|
||
instruction: 'Wähle die richtige Begrüßung aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Wie geht es dir?" auf Bisaya?',
|
||
options: ['Kumusta ka?', 'Maayo', 'Salamat', 'Palihug']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Kumusta ka?" ist die Standard-Begrüßung auf Bisaya, ähnlich wie "Wie geht es dir?"'
|
||
},
|
||
{
|
||
exerciseTypeId: 1, // gap_fill
|
||
title: 'Begrüßungen vervollständigen',
|
||
instruction: 'Fülle die Lücken mit den richtigen Bisaya-Wörtern.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Kumusta ka? Maayo {gap} (ich). Salamat.',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['ko']
|
||
},
|
||
explanation: '"Maayo ko" bedeutet "Mir geht es gut". "ko" ist "ich" auf Bisaya.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet "Salamat"?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Salamat"?',
|
||
options: ['Danke', 'Bitte', 'Entschuldigung', 'Auf Wiedersehen']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Salamat" bedeutet "Danke" auf Bisaya.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Tagesgruß erkennen',
|
||
instruction: 'Wähle den passenden Gruß für den Morgen.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Guten Morgen" auf Bisaya?',
|
||
options: ['Maayong buntag', 'Maayong gabii', 'Amping', 'Babay']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Maayong buntag" ist die übliche Form für "Guten Morgen".'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Abendgruß erkennen',
|
||
instruction: 'Wähle den passenden Gruß für den Abend.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Guten Abend" auf Bisaya?',
|
||
options: ['Maayong gabii', 'Maayong buntag', 'Amping', 'Salamat']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Maayong gabii" ist der normale Abendgruß.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Gute Nacht zuordnen',
|
||
instruction: 'Wähle die passendste Formulierung für den Schlafensmoment.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welche Formulierung passt am besten zu "Gute Nacht"?',
|
||
options: ['Maayong gabii, matulog na ta.', 'Kumusta ka?', 'Pila ang plite?', 'Tabangan tika.']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: 'Diese Form verbindet den Abendgruß direkt mit dem Schlafengehen.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Schlaf gut erkennen',
|
||
instruction: 'Wähle die passende Fürsorgeformel für die Nacht.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Schlaf gut" auf Bisaya?',
|
||
options: ['Katulog og maayo.', 'Amping.', 'Maayo ko.', 'Babay.']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Katulog og maayo." bedeutet sinngemäß "Schlaf gut."'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Müdigkeit erkennen',
|
||
instruction: 'Wähle die passende Frage vor dem Schlafengehen.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie fragst du: "Bist du schon müde?"',
|
||
options: ['Kapoy na ka?', 'Kumusta ka?', 'Asa ang sakayan?', 'Tagpila ni?']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Kapoy na ka?" ist eine natürliche Frage in der Abendroutine.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Schlafensroutine ergänzen',
|
||
instruction: 'Fülle die Lücken mit den passenden Wörtern.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} na ta. Inom sa og {gap}.',
|
||
gaps: 2
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Matulog', 'tubig']
|
||
},
|
||
explanation: '"Matulog na ta." und "Inom sa og tubig." ergeben zusammen eine sehr alltagsnahe Schlafensroutine.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Licht aus erkennen',
|
||
instruction: 'Wähle die passende Abendaufforderung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagst du: "Mach das Licht aus"?',
|
||
options: ['Patya ang suga.', 'Kumusta ka?', 'Mubayad ko.', 'Asa ang merkado?']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Patya ang suga." ist eine typische kurze Abendaufforderung.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Zudecken und Schlafwunsch',
|
||
instruction: 'Wähle die passende warme Abendformel.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welche Formulierung passt am besten zu "Deck dich zu und träum schön"?',
|
||
options: ['Tabuni ang imong kaugalingon. Damgo og nindot.', 'Tagpila ni? Salamat.', 'Asa ang sakayan? Amping.', 'Kumusta ka? Maayo ko.']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: 'Diese Kombination klingt sehr familientypisch und warm.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Verabschiedung erkennen',
|
||
instruction: 'Wähle die passende Verabschiedung aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Amping"?',
|
||
options: ['Pass auf dich auf', 'Guten Morgen', 'Danke', 'Bitte']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Amping" benutzt man beim Abschied im Sinn von "Pass auf dich auf".'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Abschiedsform erkennen',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Babay"?',
|
||
options: ['Tschüss', 'Auf Wiedersehen', 'Wie geht es dir?', 'Guten Tag']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
// Beide gelten als richtig (Lehnwort von „bye-bye“)
|
||
correctAnswer: [0, 1]
|
||
},
|
||
explanation: '"Babay" ist eine einfache Verabschiedung — vergleichbar mit „Tschüss“ oder „Auf Wiedersehen“.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Begrüßungsdialog ergänzen',
|
||
instruction: 'Ergänze die passende Antwort im Mini-Dialog.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Welche Antwort passt auf die Begrüßung?',
|
||
dialog: ['A: Kumusta ka?', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Maayo ko, salamat.',
|
||
correct: ['Maayo ko, salamat.', 'Maayo ko. Salamat.']
|
||
},
|
||
explanation: 'Eine typische kurze Antwort ist "Maayo ko, salamat."'
|
||
}),
|
||
withTypeName('dialog_completion', {
|
||
title: 'Verabschiedungsdialog ergänzen',
|
||
instruction: 'Ergänze die passende Verabschiedung.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Wie endet der kurze Dialog natürlich?',
|
||
dialog: ['A: Sige, mauna ko.', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Babay, amping.',
|
||
correct: ['Babay, amping.', 'Amping.', 'Babay. Amping.']
|
||
},
|
||
explanation: '"Babay" und "Amping" sind typische kurze Abschiedsformen.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 8,
|
||
title: 'Begrüßung frei sprechen',
|
||
instruction: 'Sprich eine kurze Begrüßung mit Frage und Antwort frei nach.',
|
||
questionData: {
|
||
type: 'speaking_from_memory',
|
||
question: 'Begrüße eine Person und antworte kurz auf "Kumusta ka?".',
|
||
expectedText: 'Kumusta ka? Maayo ko, salamat.',
|
||
keywords: ['kumusta', 'maayo', 'salamat']
|
||
},
|
||
answerData: {
|
||
type: 'speaking_from_memory'
|
||
},
|
||
explanation: 'Wichtig sind hier die Schlüsselwörter für Begrüßung, Antwort und Höflichkeit.'
|
||
},
|
||
{
|
||
exerciseTypeId: 8,
|
||
title: 'Gruß und Abschied laut sprechen',
|
||
instruction: 'Sprich einen Tagesgruß und eine kurze Verabschiedung laut.',
|
||
questionData: {
|
||
type: 'speaking_from_memory',
|
||
question: 'Sprich: "Guten Morgen" und verabschiede dich danach kurz.',
|
||
expectedText: 'Maayong buntag. Babay, amping.',
|
||
keywords: ['maayong', 'buntag', 'babay', 'amping']
|
||
},
|
||
answerData: {
|
||
type: 'speaking_from_memory'
|
||
},
|
||
explanation: 'Die Übung verbindet Begrüßung und Verabschiedung in einem kurzen Alltagspfad.'
|
||
},
|
||
{
|
||
exerciseTypeId: 8,
|
||
title: 'Abendgruß und Schlafwunsch sprechen',
|
||
instruction: 'Sprich einen Abendgruß und einen Schlafwunsch laut.',
|
||
questionData: {
|
||
type: 'speaking_from_memory',
|
||
question: 'Sprich: "Guten Abend. Schlaf gut."',
|
||
expectedText: 'Maayong gabii. Katulog og maayo.',
|
||
keywords: ['maayong', 'gabii', 'katulog', 'maayo']
|
||
},
|
||
answerData: {
|
||
type: 'speaking_from_memory'
|
||
},
|
||
explanation: 'Die Übung verankert die Abend- und Schlafensformeln für den Familienalltag.'
|
||
},
|
||
{
|
||
exerciseTypeId: 8,
|
||
title: 'Kurze Schlafensroutine sprechen',
|
||
instruction: 'Sprich eine kleine Abendroutine laut.',
|
||
questionData: {
|
||
type: 'speaking_from_memory',
|
||
question: 'Sprich: "Bist du müde? Lass uns schlafen gehen. Trink erst etwas Wasser."',
|
||
expectedText: 'Kapoy na ka? Matulog na ta. Inom sa og tubig.',
|
||
keywords: ['kapoy', 'matulog', 'tubig']
|
||
},
|
||
answerData: {
|
||
type: 'speaking_from_memory'
|
||
},
|
||
explanation: 'So wird aus Einzelwörtern eine kleine familiennahe Abendsequenz.'
|
||
},
|
||
{
|
||
exerciseTypeId: 8,
|
||
title: 'Abendsequenz mit morgen sprechen',
|
||
instruction: 'Sprich eine warme Schlusssequenz für den Abend laut.',
|
||
questionData: {
|
||
type: 'speaking_from_memory',
|
||
question: 'Sprich: "Mach das Licht aus. Deck dich zu. Bis morgen. Träum was Schönes."',
|
||
expectedText: 'Patya ang suga. Tabuni ang imong kaugalingon. Ugma nasad. Damgo og nindot.',
|
||
keywords: ['suga', 'tabuni', 'ugma', 'damgo']
|
||
},
|
||
answerData: {
|
||
type: 'speaking_from_memory'
|
||
},
|
||
explanation: 'Die Übung verbindet mehrere kleine Familienformeln zu einer natürlichen Abendsequenz.'
|
||
}
|
||
],
|
||
|
||
// Lektion 3: Familienwörter
|
||
'Familienwörter': [
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Mutter" auf Bisaya?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Mutter" auf Bisaya?',
|
||
options: ['Nanay', 'Tatay', 'Kuya', 'Ate']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Nanay" bedeutet "Mutter" auf Bisaya. "Mama" wird auch verwendet.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Vater" auf Bisaya?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Vater" auf Bisaya?',
|
||
options: ['Tatay', 'Nanay', 'Kuya', 'Ate']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Tatay" bedeutet "Vater" auf Bisaya. "Papa" wird auch verwendet.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "älterer Bruder" auf Bisaya?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "älterer Bruder" auf Bisaya?',
|
||
options: ['Kuya', 'Ate', 'Nanay', 'Tatay']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Kuya" bedeutet "älterer Bruder" auf Bisaya. Wird auch für respektvolle Anrede von älteren Männern verwendet.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "ältere Schwester" auf Bisaya?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "ältere Schwester" auf Bisaya?',
|
||
options: ['Ate', 'Kuya', 'Nanay', 'Tatay']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Ate" bedeutet "ältere Schwester" auf Bisaya. Wird auch für respektvolle Anrede von älteren Frauen verwendet.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "jüngerer Bruder" auf Bisaya?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "jüngerer Bruder" auf Bisaya?',
|
||
options: ['Dodong', 'Inday', 'Kuya', 'Ate']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Dodong" ist die gängige Bisaya-Bezeichnung für einen jüngeren Bruder (von älteren Geschwistern aus gesehen).'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "jüngere Schwester" auf Bisaya?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "jüngere Schwester" auf Bisaya?',
|
||
options: ['Inday', 'Dodong', 'Ate', 'Kuya']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Inday" ist die gängige Bisaya-Bezeichnung für eine jüngere Schwester (von älteren Geschwistern aus gesehen).'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Großmutter" auf Bisaya?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Großmutter" auf Bisaya?',
|
||
options: ['Lola', 'Lolo', 'Nanay', 'Tatay']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Lola" bedeutet "Großmutter" auf Bisaya.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Großvater" auf Bisaya?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Großvater" auf Bisaya?',
|
||
options: ['Lolo', 'Lola', 'Nanay', 'Tatay']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Lolo" bedeutet "Großvater" auf Bisaya.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1, // gap_fill
|
||
title: 'Familienwörter vervollständigen',
|
||
instruction: 'Fülle die Lücken mit den richtigen Bisaya-Familienwörtern.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} (Mutter) | {gap} (Vater) | {gap} (älterer Bruder) | {gap} (ältere Schwester) | {gap} (jüngerer Bruder) | {gap} (jüngere Schwester) | {gap} (Großmutter) | {gap} (Großvater)',
|
||
gaps: 8
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Nanay', 'Tatay', 'Kuya', 'Ate', 'Dodong', 'Inday', 'Lola', 'Lolo']
|
||
},
|
||
explanation: 'Nanay = Mutter, Tatay = Vater, Kuya = älterer Bruder, Ate = ältere Schwester, Dodong = jüngerer Bruder, Inday = jüngere Schwester, Lola = Großmutter, Lolo = Großvater.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4, // transformation
|
||
title: 'Familienwörter übersetzen',
|
||
instruction: 'Übersetze das Familienwort ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Mutter',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Nanay',
|
||
alternatives: ['Mama', 'Nanay', 'Inahan']
|
||
},
|
||
explanation: '"Nanay" oder "Mama" bedeutet "Mutter" auf Bisaya.'
|
||
},
|
||
{
|
||
exerciseTypeId: 3,
|
||
title: 'Familiensatz bauen',
|
||
instruction: 'Bilde aus den Wörtern einen kurzen Satz.',
|
||
questionData: {
|
||
type: 'sentence_building',
|
||
question: 'Baue einen Satz: "Das ist meine Mutter."',
|
||
tokens: ['Si', 'Nanay', 'nako', 'ni']
|
||
},
|
||
answerData: {
|
||
correct: ['Si Nanay nako ni.', 'Si Nanay ni nako.']
|
||
},
|
||
explanation: 'Mit "Si Nanay nako ni." stellst du deine Mutter kurz vor.'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Familie vorstellen',
|
||
instruction: 'Antworte kurz auf die Situation.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Jemand fragt dich nach deiner Familie. Stelle kurz Mutter und älteren Bruder vor.',
|
||
keywords: ['nanay', 'kuya']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Si Nanay ug si Kuya.',
|
||
keywords: ['nanay', 'kuya']
|
||
},
|
||
explanation: 'Für diese Aufgabe reichen kurze, klare Familiennennungen.'
|
||
})
|
||
],
|
||
|
||
'Familie - Verwandte & Stieffamilie': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Onkel auf Bisaya',
|
||
instruction: 'Wähle die übliche Bisaya-Bezeichnung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man „Onkel“ in dieser Lektion?',
|
||
options: ['Tito', 'Tatay', 'Kuya', 'Lolo']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Tito“ ist die gängige, spanisch geprägte Form für Onkel und wird oft auch respektvoll für nahe Bekannte genutzt.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Tante auf Bisaya',
|
||
instruction: 'Wähle die übliche Bisaya-Bezeichnung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man „Tante“ in dieser Lektion?',
|
||
options: ['Tita', 'Nanay', 'Ate', 'Lola']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Tita“ ist die gängige Form für Tante.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Enkelsohn präzisieren',
|
||
instruction: 'Wähle die präzise Form mit Geschlecht.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man „Enkelsohn“ klar und eindeutig?',
|
||
options: ['Apo nga lalaki', 'Apo nga babaye', 'Pamangkin nga lalaki', 'Primo']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Apo“ allein ist mehrdeutig; mit nga lalaki / nga babaye meint man Enkelsohn bzw. Enkelin.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Nichte benennen',
|
||
instruction: 'Wähle die passende Form.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man „Nichte“?',
|
||
options: ['Pamangkin nga babaye', 'Pamangkin nga lalaki', 'Prima', 'Inday']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Pamangkin nga babaye“ = Nichte; „Pamangkin nga lalaki“ = Neffe.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Cousin und Cousine',
|
||
instruction: 'Ordne die weibliche Form.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welches Wort passt zu „Cousine“?',
|
||
options: ['Prima', 'Primo', 'Tita', 'Ate']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Primo“ = Cousin (männlich), „Prima“ = Cousine – gängige Lehnformen.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Stiefvater',
|
||
instruction: 'Wähle die im Kurs geübte Umschreibung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welche Form nutzt du für „Stiefvater“?',
|
||
options: ['Ikaduha nga Tatay', 'Tatay sa lain', 'Lolo', 'Kuya']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Ikaduha nga Tatay“ (wörtlich zweiter Vater) ist eine verständliche, alltagstaugliche Umschreibung.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Stiefmutter',
|
||
instruction: 'Wähle die passende Umschreibung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welche Form passt zu „Stiefmutter“?',
|
||
options: ['Ikaduha nga Nanay', 'Nanay', 'Tita', 'Ate']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Ikaduha nga Nanay“ entspricht der gleichen Logik wie beim Stiefvater.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Verwandtschaft – erste Reihe',
|
||
instruction: 'Fülle die Lücken (exakt wie in der Lektion).',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} (Onkel) | {gap} (Tante) | {gap} (Cousin) | {gap} (Cousine)',
|
||
gaps: 4
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Tito', 'Tita', 'Primo', 'Prima']
|
||
},
|
||
explanation: 'Tito/Tita und Primo/Prima sind die Kernpaare für die erweiterte Verwandtschaft.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Enkel und Pamangkin',
|
||
instruction: 'Fülle die Lücken mit den Geschlechtsformen.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} (Enkelsohn) | {gap} (Enkelin) | {gap} (Neffe) | {gap} (Nichte)',
|
||
gaps: 4
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Apo nga lalaki', 'Apo nga babaye', 'Pamangkin nga lalaki', 'Pamangkin nga babaye']
|
||
},
|
||
explanation: 'Mit nga lalaki / nga babaye unterscheidest du bei Apo und Pamangkin das Geschlecht klar.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Stieffamilie ergänzen',
|
||
instruction: 'Fülle die Lücken.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} (Stiefvater) | {gap} (Stiefmutter) | {gap} (Stiefsohn) | {gap} (Stieftochter)',
|
||
gaps: 4
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: [
|
||
'Ikaduha nga Tatay',
|
||
'Ikaduha nga Nanay',
|
||
'Anak sa ikaduha nga Tatay',
|
||
'Anak sa ikaduha nga Nanay'
|
||
]
|
||
},
|
||
explanation: 'Stieffamilie wird oft mit Ikaduha nga … und anak sa … beschrieben statt mit einem einzigen Wort wie im Deutschen.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Stiefvater übersetzen',
|
||
instruction: 'Übersetze ins Bisaya (Form aus der Lektion).',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Stiefvater',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Ikaduha nga Tatay',
|
||
alternatives: ['Ikaduha nga Tatay', 'ikaduha nga tatay']
|
||
},
|
||
explanation: 'Die Groß-/Kleinschreibung ist in der Bewertung oft tolerant; Inhalt zählt.'
|
||
},
|
||
{
|
||
exerciseTypeId: 3,
|
||
title: 'Onkel vorstellen',
|
||
instruction: 'Ordne die Wörter zu einem kurzen Satz.',
|
||
questionData: {
|
||
type: 'sentence_building',
|
||
question: 'Baue: „Das ist mein Onkel.“',
|
||
tokens: ['Si', 'Tito', 'nako', 'ni']
|
||
},
|
||
answerData: {
|
||
correct: ['Si Tito nako ni.', 'Si Tito ni nako.']
|
||
},
|
||
explanation: 'Gleiches Muster wie bei Nanay: Si … nako ni.'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Stieffamilie kurz erklären',
|
||
instruction: 'Antworte kurz auf Bisaya.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Jemand fragt, wer der Mann neben deiner Mutter ist – es ist dein Stiefvater. Antworte in einem kurzen Satz.',
|
||
keywords: ['ikaduha', 'tatay']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Ikaduha nga Tatay nako.',
|
||
keywords: ['ikaduha', 'tatay']
|
||
},
|
||
explanation: '„Ikaduha nga Tatay nako.“ ist eine klare, höfliche Kurzantwort.'
|
||
})
|
||
],
|
||
|
||
'Essen & Fürsorge': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Fürsorgefrage verstehen',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Nikaon na ka?"?',
|
||
options: ['Hast du schon gegessen?', 'Bist du müde?', 'Kommst du nach Hause?', 'Möchtest du Wasser?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Nikaon na ka?" ist eine sehr fürsorgliche Alltagsfrage.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Essensdialog ergänzen',
|
||
instruction: 'Fülle die Lücken mit den passenden Wörtern.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Nikaon {gap} ka? {gap} ta!',
|
||
gaps: 2
|
||
},
|
||
answerData: {
|
||
answers: ['na', 'Kaon']
|
||
},
|
||
explanation: '"na" markiert hier den bereits eingetretenen Zustand; "Kaon ta!" heißt "Lass uns essen!".'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Einladung zum Essen ergänzen',
|
||
instruction: 'Ergänze die passende Antwort.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Welche Antwort passt auf die Einladung?',
|
||
dialog: ['A: Kaon ta!', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Oo, gusto ko.',
|
||
correct: ['Oo, gusto ko.', 'Oo, mokaon ko.']
|
||
},
|
||
explanation: 'Eine natürliche kurze Reaktion ist "Oo, gusto ko."'
|
||
}),
|
||
withTypeName('situational_response', {
|
||
title: 'Fürsorglich reagieren',
|
||
instruction: 'Reagiere passend auf die Situation.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Jemand sieht hungrig aus. Frage fürsorglich nach und biete Essen an.',
|
||
keywords: ['nikaon', 'kaon']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Nikaon na ka? Kaon ta.',
|
||
keywords: ['nikaon', 'kaon']
|
||
},
|
||
explanation: 'Die Übung trainiert einen sehr typischen fürsorglichen Mini-Dialog.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: '„Sehr lecker" erkennen',
|
||
instruction: 'Wähle die passende Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet „lami kaayo"?',
|
||
options: ['Sehr lecker', 'Zu salzig', 'Zu kalt', 'Noch nicht fertig']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Lami kaayo" drückt aus, dass das Essen sehr gut schmeckt.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Dank für das Essen',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Danke für das Essen',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Salamat sa pagkaon',
|
||
alternatives: ['Salamat sa kaon', 'Daghang salamat sa pagkaon']
|
||
},
|
||
explanation: '„Salamat sa pagkaon" ist eine natürliche Danksagung nach dem Essen.'
|
||
}
|
||
],
|
||
|
||
// Lektion: Haus & Familie (Haus, Räume, Familie, typische Kurzsätze)
|
||
'Haus & Familie': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: '„Haus“ auf Bisaya',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man „Haus“ auf Bisaya?',
|
||
options: ['Balay', 'Kwarto', 'Kusina', 'Pamilya']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Balay“ ist das gängige Wort für Haus.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: '„Zimmer“ auf Bisaya',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man „Zimmer“ auf Bisaya?',
|
||
options: ['Kwarto', 'Balay', 'Kusina', 'Sala']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Kwarto“ bezeichnet ein Zimmer (oft Schlafzimmer).'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: '„Küche“ auf Bisaya',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man „Küche“ auf Bisaya?',
|
||
options: ['Kusina', 'Sala', 'Banyo', 'Kwarto']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Kusina“ kommt aus dem Spanischen und ist überall verbreitet.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: '„Wohnzimmer“ auf Bisaya',
|
||
instruction: 'Wähle die übliche Bezeichnung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man oft „Wohnzimmer“?',
|
||
options: ['Sala', 'Kwarto', 'Kusina', 'Banyo']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Sala“ ist das übliche Wort für das Wohnzimmer.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: '„Badezimmer“ auf Bisaya',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man „Badezimmer“?',
|
||
options: ['Banyo', 'Kusina', 'Sala', 'Atop']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Banyo“ wird für Bad/Badezimmer verwendet.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: '„Tür“ und „Fenster“',
|
||
instruction: 'Ordne die Bedeutung zu.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welches Wort bedeutet „Tür“?',
|
||
options: ['Pultahan', 'Bintana', 'Atop', 'Balay']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Pultahan“ = Tür; „Bintana“ = Fenster; „Atop“ = Dach.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Frage nach dem Ort',
|
||
instruction: 'Wähle die passende deutsche Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet „Asa ang kusina?"?',
|
||
options: ['Wo ist die Küche?', 'Wo ist das Bad?', 'Wo ist Papa?', 'Was isst du?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Asa“ fragt nach dem Ort; „ang kusina“ = die Küche.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: '„Familie“ und „unsere Familie“',
|
||
instruction: 'Wähle die richtige Form.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man „unsere Familie“?',
|
||
options: ['Among pamilya', 'Akoang pamilya', 'Imong pamilya', 'Iyang pamilya']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Among“ = unser (inklusiv wir); passt gut zur Familie.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Haus und Räume – Lücken',
|
||
instruction: 'Fülle die Lücken (exakt wie in der Lektion).',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} (Haus) | {gap} (Zimmer) | {gap} (Küche) | {gap} (Wohnzimmer) | {gap} (Badezimmer) | {gap} (Familie)',
|
||
gaps: 6
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Balay', 'Kwarto', 'Kusina', 'Sala', 'Banyo', 'Pamilya']
|
||
},
|
||
explanation: 'Die sechs Wörter bilden den Kernwortschatz dieser Lektion.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Zu Hause sein',
|
||
instruction: 'Ergänze das passende Wort.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Naa ko sa {gap}. (Ich bin zu Hause.)',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['balay']
|
||
},
|
||
explanation: '„Naa ko sa balay.“ = Ich bin zu Hause.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Unser Haus benennen',
|
||
instruction: 'Übersetze den kurzen Satz ins Bisaya (nur Wortschatz und Muster aus dieser Lektion).',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Unser Haus.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Ang among balay',
|
||
alternatives: ['Among balay.', 'Ang among balay.']
|
||
},
|
||
explanation: '„Ang among balay.“ = unser Haus; „among“ (inklusiv) und „balay“ sind die Lernziele dieser Einheit.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'In der Küche',
|
||
instruction: 'Übersetze den Satz ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Sie sind in der Küche.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Naa sila sa kusina',
|
||
alternatives: ['Naa sila sa kusina.', 'naa sila sa kusina']
|
||
},
|
||
explanation: '„Naa sila sa …“ = Sie sind in/am …'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Nach der Küche fragen',
|
||
instruction: 'Ergänze die passende Antwort (Ortsangaben wie didto/luyo kommen in der nächsten Lektion).',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Welche Antwort passt?',
|
||
dialog: ['A: Asa ang kusina?', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Naa sila sa kusina.',
|
||
correct: [
|
||
'Naa sila sa kusina.',
|
||
'Naa siya sa kusina.',
|
||
'Naa ko sa kusina.',
|
||
'Sa kusina.'
|
||
]
|
||
},
|
||
explanation: 'Mit „Naa … sa kusina“ kannst du sagen, wo sich jemand befindet – dasselbe Muster wie „Naa sila sa kusina.“ in der Lektion.'
|
||
}),
|
||
withTypeName('situational_response', {
|
||
title: 'Zu Hause kurz beschreiben',
|
||
instruction: 'Antworte in einem kurzen Satz auf Bisaya.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Jemand fragt, wo du bist. Sage, dass du zu Hause bist.',
|
||
keywords: ['naa', 'balay']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Naa ko sa balay.',
|
||
keywords: ['naa', 'balay']
|
||
},
|
||
explanation: '„Naa ko sa balay.“ ist die natürliche Kurzantwort.'
|
||
})
|
||
],
|
||
|
||
// Lektion 14: Ort & Richtung (Asa, dinhi, didto, padulong)
|
||
'Ort & Richtung': [
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet \"Asa\"?',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet \"Asa\" auf Bisaya?',
|
||
options: ['Wo / Wohin', 'Hier', 'Dort', 'Warum']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '\"Asa\" bedeutet \"Wo\" oder je nach Kontext \"Wohin\".'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet \"dinhi\"?',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet \"dinhi\" auf Bisaya?',
|
||
options: ['Hier', 'Dort', 'Drinnen', 'Draußen']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '\"dinhi\" bedeutet \"hier\".'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet \"didto\"?',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet \"didto\" auf Bisaya?',
|
||
options: ['Dort', 'Hier', 'Oben', 'Unten']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '\"didto\" bedeutet \"dort\" (an einem entfernten Ort).'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet \"padulong\"?',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet \"padulong\" auf Bisaya?',
|
||
options: ['Unterwegs nach / auf dem Weg zu', 'Ankommen', 'Abfahren', 'Zurückkommen']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '\"padulong\" beschreibt eine Bewegung in Richtung eines Zieles.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1, // gap_fill
|
||
title: 'Ort-Wörter einsetzen',
|
||
instruction: 'Fülle die Lücken mit den richtigen Ort-Wörtern.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} ka? (Wo bist du?) | Naa ko {gap}. (Ich bin hier.) | Adto ta {gap}. (Lass uns dorthin gehen.)',
|
||
gaps: 3
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Asa', 'dinhi', 'didto']
|
||
},
|
||
explanation: 'Asa = wo, dinhi = hier, didto = dort.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1, // gap_fill
|
||
title: 'Richtungen beschreiben',
|
||
instruction: 'Fülle die Lücken mit den richtigen Bisaya-Wörtern.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} ko sa merkado. (Ich gehe zum Markt.) | {gap} ta didto. (Lass uns dorthin gehen.)',
|
||
gaps: 2
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Padulong', 'Padulong']
|
||
},
|
||
explanation: '\"Padulong\" beschreibt, dass man unterwegs zu einem Ziel ist.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4, // transformation
|
||
title: 'Frage nach dem Ort übersetzen',
|
||
instruction: 'Übersetze den Satz ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Wo ist die Kirche?',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Asa ang simbahan?',
|
||
alternatives: ['Asa dapit ang simbahan?', 'Asa man ang simbahan?']
|
||
},
|
||
explanation: '\"simbahan\" = Kirche, \"Asa ang ...?\" = Wo ist ...?'
|
||
}
|
||
],
|
||
|
||
// Lektion 15: Zeitformen - Grundlagen
|
||
'Zeitformen - Grundlagen': [
|
||
{
|
||
exerciseTypeId: 4, // transformation
|
||
title: 'Vergangenheit verstehen',
|
||
instruction: 'Was bedeutet "Ni-kaon ko"?',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Ni-kaon ko',
|
||
sourceLanguage: 'Bisaya',
|
||
targetLanguage: 'Deutsch'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Ich habe gegessen',
|
||
alternatives: ['I ate', 'I have eaten']
|
||
},
|
||
explanation: 'Das Präfix "Ni-" zeigt die Vergangenheit an. "Ni-kaon ko" bedeutet "Ich habe gegessen".'
|
||
},
|
||
{
|
||
exerciseTypeId: 4, // transformation
|
||
title: 'Gegenwart verstehen',
|
||
instruction: 'Was bedeutet "Nagkaon ko karon"?',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Nagkaon ko karon',
|
||
sourceLanguage: 'Bisaya',
|
||
targetLanguage: 'Deutsch'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Ich esse gerade jetzt',
|
||
alternatives: ['Ich esse jetzt', 'Ich bin gerade am Essen']
|
||
},
|
||
explanation: 'nag- plus "karon" markiert hier eine laufende Handlung in der Gegenwart.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4, // transformation
|
||
title: 'Zukunft verstehen',
|
||
instruction: 'Was bedeutet "Mo-kaon ko"?',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Mo-kaon ko',
|
||
sourceLanguage: 'Bisaya',
|
||
targetLanguage: 'Deutsch'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Ich werde essen',
|
||
alternatives: ['I will eat', 'I am going to eat']
|
||
},
|
||
explanation: 'Das Präfix "Mo-" zeigt die Zukunft an. "Mo-kaon ko" bedeutet "Ich werde essen".'
|
||
},
|
||
{
|
||
exerciseTypeId: 1, // gap_fill
|
||
title: 'Zeitformen erkennen',
|
||
instruction: 'Setze die richtigen Präfixe ein.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap}-kaon ko ganiha (Vergangenheit) | {gap}kaon ko karon (Gegenwart) | {gap}-kaon ko ugma (Zukunft)',
|
||
gaps: 3
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Ni', 'Nag', 'Mo']
|
||
},
|
||
explanation: 'Ni- für Vergangenheit, nag- für laufende Gegenwart, mo- für Zukunft.'
|
||
},
|
||
withTypeName('gap_fill', {
|
||
title: 'Zeitmuster anwenden',
|
||
instruction: 'Verwende das Verb "adto" in Vergangenheit, Gegenwart und Zukunft. Trage jede Form in das passende Feld ein.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Vergangenheit: {gap} | Gegenwart: {gap} | Zukunft: {gap}',
|
||
gaps: 3
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Ni-adto ko', 'Nag-adto ko', 'Mo-adto ko']
|
||
},
|
||
explanation: 'Die Übung trainiert den direkten Wechsel derselben Handlung mit "adto" über drei Zeitbezüge.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 3,
|
||
title: 'Drei Zeiten nacheinander bauen',
|
||
instruction: 'Schreibe Vergangenheit, Gegenwart und Zukunft nacheinander auf.',
|
||
questionData: {
|
||
type: 'sentence_building',
|
||
question: 'Formuliere: "Ich habe gegessen. Ich esse jetzt. Ich werde später essen."',
|
||
tokens: ['Ni-kaon', 'ko', 'Nagkaon', 'ko', 'karon', 'Mo-kaon', 'ko', 'unya']
|
||
},
|
||
answerData: {
|
||
correct: [
|
||
'Ni-kaon ko. Nagkaon ko karon. Mo-kaon ko unya.',
|
||
'Nikaon ko. Nagkaon ko karon. Mokaon ko unya.'
|
||
]
|
||
},
|
||
explanation: 'Die Übung trainiert den systematischen Wechsel zwischen Vergangenheit, Gegenwart und Zukunft.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Zeitmarker auswählen',
|
||
instruction: 'Wähle den passenden Marker für eine laufende Handlung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welcher Marker passt typischerweise zu einer laufenden Handlung in der Gegenwart?',
|
||
options: ['Nag-/ga-', 'Ni-', 'Mo-', 'Gi-']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: 'Nag-/ga- steht hier für laufende Gegenwart, ni- für Vergangenheit und mo- für Zukunft.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Zeitwort zuordnen',
|
||
instruction: 'Wähle das passende Zeitwort zur Zukunft.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welches Zeitwort passt am besten zu einer Zukunftsaussage?',
|
||
options: ['ugma', 'ganiha', 'karon', 'didto']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„ugma" bedeutet morgen und unterstützt Zukunftsformen.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Zeitwechsel im Mini-Dialog',
|
||
instruction: 'Ergänze eine passende Zukunftsantwort.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'A sagt, was vorhin war. B reagiert mit Zukunft.',
|
||
dialog: ['A: Ni-kaon ko ganiha.', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Mo-kaon ko unya.',
|
||
correct: ['Mo-kaon ko unya.', 'Mokaon ko unya.']
|
||
},
|
||
explanation: 'Der Dialog trainiert den Wechsel von Vergangenheit auf Zukunft.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 8,
|
||
title: 'Zeitformen frei anwenden',
|
||
instruction: 'Sprich drei kurze Sätze: gestern/jetzt/morgen.',
|
||
questionData: {
|
||
type: 'speaking_from_memory',
|
||
question: 'Nutze ein Verb in Vergangenheit, Gegenwart und Zukunft.',
|
||
expectedText: 'Ni-..., nag-..., mo-...',
|
||
keywords: ['ni', 'nag', 'mo', 'ganiha', 'karon', 'ugma']
|
||
},
|
||
answerData: {
|
||
type: 'speaking_from_memory'
|
||
},
|
||
explanation: 'Zum Abschluss nutzt du die Zeitmarker ohne Vorgabe frei im eigenen Mini-Output.'
|
||
}
|
||
],
|
||
|
||
// Lektion 16: Zeit & Datum
|
||
'Zeit & Datum': [
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Zeitwörter erkennen',
|
||
instruction: 'Wähle die richtige Bedeutung aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "ugma"?',
|
||
options: ['morgen', 'gestern', 'jetzt', 'später']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"ugma" = morgen. "gahapon" = gestern, "karon" = jetzt/heute, "unya" = später.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4, // transformation
|
||
title: 'Zeitwort übersetzen',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Heute',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Karon',
|
||
alternatives: ['Karong adlawa']
|
||
},
|
||
explanation: '"karon" heißt „jetzt/heute“. „karong adlawa“ ist eine betonte Form für „heute“.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1, // gap_fill
|
||
title: 'Gestern–heute–morgen einsetzen',
|
||
instruction: 'Setze das passende Zeitwort ein.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} ni-adto ko (gestern) | {gap} naa ko diri (jetzt/heute) | {gap} mo-adto ko (morgen)',
|
||
gaps: 3
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Gahapon', 'Karon', 'Ugma']
|
||
},
|
||
explanation: 'gahapon = gestern, karon = jetzt/heute, ugma = morgen. Die Verben können zusätzlich Ni-/Mo- tragen.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4, // transformation
|
||
title: 'Kurzsatz mit Zeitmarker',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Ich gehe morgen.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Mo-adto ko ugma',
|
||
alternatives: ['Moadto ko ugma.']
|
||
},
|
||
explanation: '"Mo-" markiert häufig Zukunft/Absicht. Mit "ugma" wird es eindeutig „morgen“.'
|
||
}
|
||
],
|
||
|
||
// Lektion 25: Höflichkeitsformen
|
||
'Höflichkeitsformen': [
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Bitte langsam"?',
|
||
instruction: 'Wähle die höfliche Form aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Bitte langsam" auf Bisaya?',
|
||
options: ['Hinay-hinay lang', 'Palihug', 'Salamat', 'Maayo']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Hinay-hinay lang" bedeutet "Bitte langsam" und ist sehr höflich.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1, // gap_fill
|
||
title: 'Höfliche Sätze vervollständigen',
|
||
instruction: 'Fülle die Lücken mit höflichen Wörtern.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} lang (Bitte langsam), wala ko kasabot. {gap} ka mubalik? (Bitte wiederholen)',
|
||
gaps: 2
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Hinay-hinay', 'Palihug']
|
||
},
|
||
explanation: '"Hinay-hinay lang" = "Bitte langsam", "Palihug" = "Bitte".'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet "Palihug"?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Palihug"?',
|
||
options: ['Bitte', 'Danke', 'Entschuldigung', 'Gern geschehen']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Palihug" bedeutet "Bitte" auf Bisaya und wird für höfliche Bitten verwendet.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: '„Danke" auf Bisaya',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Danke',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Salamat',
|
||
alternatives: ['Daghang salamat', 'Salamat kaayo']
|
||
},
|
||
explanation: '„Salamat" ist die grundlegende Danksagung.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Höflich nach Wiederholung fragen',
|
||
instruction: 'Ergänze die passende Bitte.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Welche Antwort passt, wenn du etwas nicht verstanden hast?',
|
||
dialog: ['A: Wala ko kasabot.', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Palihug ka mubalik.',
|
||
correct: ['Palihug ka mubalik.', 'Palihug balika.']
|
||
},
|
||
explanation: 'Nach „Wala ko kasabot" folgt oft eine höfliche Bitte um Wiederholung.'
|
||
}),
|
||
withTypeName('situational_response', {
|
||
title: 'Höflich um langsames Sprechen bitten',
|
||
instruction: 'Reagiere kurz und höflich.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Bitte jemanden, etwas langsamer zu sprechen, weil du nur wenig verstehst.',
|
||
keywords: ['hinay', 'kasabot']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Hinay-hinay lang. Wala ko kasabot tanan.',
|
||
keywords: ['hinay', 'kasabot']
|
||
},
|
||
explanation: '„Hinay-hinay lang" kombiniert mit Verständnisproblem ist sehr alltagstauglich.'
|
||
})
|
||
],
|
||
|
||
// Lektion: Überlebenssätze
|
||
'Überlebenssätze': [
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Ich verstehe nicht"?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Ich verstehe nicht" auf Bisaya?',
|
||
options: ['Wala ko kasabot', 'Palihug', 'Salamat', 'Maayo']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Wala ko kasabot" bedeutet "Ich verstehe nicht" - sehr wichtig für Anfänger!'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Kannst du das wiederholen?"?',
|
||
instruction: 'Wähle die richtige Bitte aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Kannst du das wiederholen?" auf Bisaya?',
|
||
options: ['Palihug ka mubalik?', 'Salamat', 'Maayo', 'Kumusta ka?']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Palihug ka mubalik?" bedeutet "Bitte kannst du wiederholen?" - essentiell für das Lernen!'
|
||
},
|
||
{
|
||
exerciseTypeId: 1, // gap_fill
|
||
title: 'Überlebenssätze vervollständigen',
|
||
instruction: 'Fülle die Lücken mit den richtigen Bisaya-Wörtern.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} ko kasabot (Ich verstehe nicht). {gap} ka mubalik? (Bitte wiederholen) {gap} lang (Bitte langsam).',
|
||
gaps: 3
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Wala', 'Palihug', 'Hinay-hinay']
|
||
},
|
||
explanation: '"Wala ko kasabot" = "Ich verstehe nicht", "Palihug ka mubalik?" = "Bitte wiederholen", "Hinay-hinay lang" = "Bitte langsam".'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Wo ist...?"?',
|
||
instruction: 'Wähle die richtige Frage aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Wo ist die Toilette?" auf Bisaya?',
|
||
options: ['Asa ang CR?', 'Kumusta ka?', 'Salamat', 'Maayo']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Asa ang CR?" bedeutet "Wo ist die Toilette?" - "Asa" = "Wo", "CR" = "Comfort Room" (Toilette).'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Wie viel kostet das?"?',
|
||
instruction: 'Wähle die richtige Frage aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Wie viel kostet das?" auf Bisaya?',
|
||
options: ['Tagpila ni?', 'Asa ni?', 'Unsa ni?', 'Kinsa ni?']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Tagpila ni?" bedeutet "Wie viel kostet das?" - sehr nützlich beim Einkaufen!'
|
||
},
|
||
{
|
||
exerciseTypeId: 1, // gap_fill
|
||
title: 'Wichtige Fragen bilden',
|
||
instruction: 'Fülle die Lücken mit den richtigen Fragewörtern.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} ang CR? (Wo ist die Toilette?) | {gap} ni? (Wie viel kostet das?) | {gap} ni? (Was ist das?)',
|
||
gaps: 3
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Asa', 'Tagpila', 'Unsa']
|
||
},
|
||
explanation: '"Asa" = "Wo", "Tagpila" = "Wie viel", "Unsa" = "Was".'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Entschuldigung"?',
|
||
instruction: 'Wähle die richtige Entschuldigung aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Entschuldigung" auf Bisaya?',
|
||
options: ['Pasensya', 'Salamat', 'Palihug', 'Maayo']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Pasensya" bedeutet "Entschuldigung" oder "Entschuldige bitte" - wichtig für höfliche Kommunikation.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4, // transformation
|
||
title: 'Überlebenssätze übersetzen',
|
||
instruction: 'Übersetze den Satz ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Ich spreche kein Bisaya',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Dili ko mag-Bisaya',
|
||
alternatives: ['Wala ko mag-Bisaya', 'Dili ko makasabot Bisaya']
|
||
},
|
||
explanation: '"Dili ko mag-Bisaya" bedeutet "Ich spreche kein Bisaya" - nützlich, um zu erklären, dass du noch lernst.'
|
||
}
|
||
],
|
||
|
||
// Auch für "Überlebenssätze - Teil 1" und "Überlebenssätze - Teil 2"
|
||
'Überlebenssätze - Teil 1': [
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Ich verstehe nicht"?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Ich verstehe nicht" auf Bisaya?',
|
||
options: ['Wala ko kasabot', 'Palihug', 'Salamat', 'Maayo']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Wala ko kasabot" bedeutet "Ich verstehe nicht" - sehr wichtig für Anfänger!'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Kannst du das wiederholen?"?',
|
||
instruction: 'Wähle die richtige Bitte aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Kannst du das wiederholen?" auf Bisaya?',
|
||
options: ['Palihug ka mubalik?', 'Salamat', 'Maayo', 'Kumusta ka?']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Palihug ka mubalik?" bedeutet "Bitte kannst du wiederholen?" - essentiell für das Lernen!'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Wo ist...?"?',
|
||
instruction: 'Wähle die richtige Frage aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Wo ist die Toilette?" auf Bisaya?',
|
||
options: ['Asa ang CR?', 'Kumusta ka?', 'Salamat', 'Maayo']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Asa ang CR?" bedeutet "Wo ist die Toilette?" - "Asa" = "Wo", "CR" = "Comfort Room" (Toilette).'
|
||
},
|
||
{
|
||
exerciseTypeId: 1, // gap_fill
|
||
title: 'Überlebenssätze vervollständigen',
|
||
instruction: 'Fülle die Lücken mit den richtigen Bisaya-Wörtern.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} ko kasabot (Ich verstehe nicht). {gap} ka mubalik? (Bitte wiederholen)',
|
||
gaps: 2
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Wala', 'Palihug']
|
||
},
|
||
explanation: '"Wala ko kasabot" = "Ich verstehe nicht", "Palihug ka mubalik?" = "Bitte wiederholen".'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: '„Wo ist die Toilette?" übersetzen',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Wo ist die Toilette?',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Asa ang CR?',
|
||
alternatives: ['Asa ang banyo?', 'Asa dapit ang CR?']
|
||
},
|
||
explanation: '„Asa ang CR?" ist die gängige Kurzform für die Toilette.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Verständnisproblem klären',
|
||
instruction: 'Ergänze die höfliche Bitte.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Was sagst du, wenn du nichts verstanden hast?',
|
||
dialog: ['A: Kumusta ka?', 'B: Wala ko kasabot. ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Palihug ka mubalik.',
|
||
correct: ['Palihug ka mubalik.', 'Palihug balika.']
|
||
},
|
||
explanation: 'Nach dem Verständnisproblem folgt oft eine Bitte um Wiederholung.'
|
||
})
|
||
],
|
||
|
||
'Überlebenssätze - Teil 2': [
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Wie viel kostet das?"?',
|
||
instruction: 'Wähle die richtige Frage aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Wie viel kostet das?" auf Bisaya?',
|
||
options: ['Tagpila ni?', 'Asa ni?', 'Unsa ni?', 'Kinsa ni?']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Tagpila ni?" bedeutet "Wie viel kostet das?" - sehr nützlich beim Einkaufen!'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Entschuldigung"?',
|
||
instruction: 'Wähle die richtige Entschuldigung aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Entschuldigung" auf Bisaya?',
|
||
options: ['Pasensya', 'Salamat', 'Palihug', 'Maayo']
|
||
},
|
||
answerData: {
|
||
type: 'multiple_choice',
|
||
correctAnswer: 0
|
||
},
|
||
explanation: '"Pasensya" bedeutet "Entschuldigung" oder "Entschuldige bitte" - wichtig für höfliche Kommunikation.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1, // gap_fill
|
||
title: 'Wichtige Fragen bilden',
|
||
instruction: 'Fülle die Lücken mit den richtigen Fragewörtern.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} ni? (Wie viel kostet das?) | {gap} ni? (Was ist das?) | {gap} lang (Bitte langsam)',
|
||
gaps: 3
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Tagpila', 'Unsa', 'Hinay-hinay']
|
||
},
|
||
explanation: '"Tagpila" = "Wie viel", "Unsa" = "Was", "Hinay-hinay lang" = "Bitte langsam".'
|
||
},
|
||
{
|
||
exerciseTypeId: 4, // transformation
|
||
title: 'Überlebenssätze übersetzen',
|
||
instruction: 'Übersetze den Satz ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Ich spreche kein Bisaya',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Dili ko mag-Bisaya',
|
||
alternatives: ['Wala ko mag-Bisaya', 'Dili ko makasabot Bisaya']
|
||
},
|
||
explanation: '"Dili ko mag-Bisaya" bedeutet "Ich spreche kein Bisaya" - nützlich, um zu erklären, dass du noch lernst.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: '„Entschuldigung" erkennen',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet „Pasensya"?',
|
||
options: ['Entschuldigung / Geduld bitte', 'Danke', 'Bitte', 'Guten Tag']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Pasensya" nutzt man für Entschuldigung oder um Geduld zu bitten.'
|
||
},
|
||
withTypeName('pattern_drill', {
|
||
title: 'Preisfrage bilden',
|
||
instruction: 'Bilde die übliche Kurzfrage nach dem Preis.',
|
||
questionData: {
|
||
type: 'pattern_drill',
|
||
question: 'Verwende „Tagpila" für dieses Ding vor dir.',
|
||
pattern: 'Tagpila + ni?'
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Tagpila ni?',
|
||
correct: ['Tagpila ni?', 'Tagpila man ni?']
|
||
},
|
||
explanation: '„Tagpila ni?" ist die Standard-Preisfrage für ein konkretes Objekt.'
|
||
})
|
||
],
|
||
|
||
// Lektion 11: Alltagsgespräche - Teil 1 (~20–30 Min Übungsmaterial)
|
||
'Alltagsgespräche - Teil 1': [
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Wie war dein Tag?"?',
|
||
instruction: 'Wähle die richtige Frage aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Wie war dein Tag?" auf Bisaya?',
|
||
options: ['Kumusta ang imong adlaw?', 'Kumusta ka?', 'Unsa ni?', 'Asa ka?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Kumusta ang imong adlaw?" bedeutet "Wie war dein Tag?" - typische Alltagsfrage.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Was machst du?"?',
|
||
instruction: 'Wähle die richtige Frage aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Was machst du?" auf Bisaya?',
|
||
options: ['Unsa imong ginabuhat?', 'Kumusta ka?', 'Asa ka?', 'Tagpila ni?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Unsa imong ginabuhat?" bedeutet "Was machst du?" - "Unsa" = was, "ginabuhat" = machst.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet "Maayo ra"?',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Maayo ra"?',
|
||
options: ['Es geht (so lala)', 'Sehr gut', 'Schlecht', 'Danke']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Maayo ra" bedeutet "Es geht" oder "So lala" - typische Antwort auf "Wie geht es dir?"'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet "Nagtrabaho ko"?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Nagtrabaho ko"?',
|
||
options: ['Ich arbeite', 'Ich habe gegessen', 'Ich schlafe', 'Ich gehe']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Nagtrabaho ko" bedeutet "Ich arbeite" - "trabaho" = Arbeit.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet "Busy ko"?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Busy ko"?',
|
||
options: ['Ich bin beschäftigt', 'Ich bin müde', 'Ich bin glücklich', 'Ich schlafe']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Busy ko" bedeutet "Ich bin beschäftigt" - "busy" wurde aus dem Englischen übernommen.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet "Kapoy ko"?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Kapoy ko"?',
|
||
options: ['Ich bin müde', 'Ich bin beschäftigt', 'Ich bin krank', 'Ich bin glücklich']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Kapoy ko" bedeutet "Ich bin müde" - "kapoy" = müde.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet "Nagpahuway ko"?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Nagpahuway ko"?',
|
||
options: ['Ich ruhe mich aus', 'Ich arbeite', 'Ich schlafe', 'Ich esse']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Nagpahuway ko" bedeutet "Ich ruhe mich aus" - "pahuway" = Ruhe.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Wie heißt du?"?',
|
||
instruction: 'Wähle die richtige Frage aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Wie heißt du?" auf Bisaya?',
|
||
options: ['Unsa imong ngalan?', 'Kumusta ka?', 'Kinsa ka?', 'Asa ka?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Unsa imong ngalan?" bedeutet "Wie heißt du?" - "ngalan" = Name.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet "Kinsa ka?"?',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Kinsa ka?"?',
|
||
options: ['Wer bist du?', 'Wo bist du?', 'Was machst du?', 'Wie geht es dir?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Kinsa ka?" bedeutet "Wer bist du?" - "kinsa" = wer.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet "Nalipay ko"?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Nalipay ko"?',
|
||
options: ['Ich bin glücklich', 'Ich bin traurig', 'Ich bin müde', 'Ich bin krank']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Nalipay ko" bedeutet "Ich bin glücklich" - "lipay" = glücklich.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet "Naa koy trabaho"?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Naa koy trabaho"?',
|
||
options: ['Ich habe Arbeit', 'Ich habe keine Arbeit', 'Ich arbeite', 'Ich ruhe mich aus']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Naa koy trabaho" bedeutet "Ich habe Arbeit" - "naa" = haben, "trabaho" = Arbeit.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet "Wala koy trabaho"?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Wala koy trabaho"?',
|
||
options: ['Ich habe keine Arbeit', 'Ich habe Arbeit', 'Ich arbeite', 'Ich bin müde']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Wala koy trabaho" bedeutet "Ich habe keine Arbeit" - "wala" = nicht haben.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1, // gap_fill
|
||
title: 'Alltagsgespräch vervollständigen',
|
||
instruction: 'Fülle die Lücken mit den richtigen Bisaya-Wörtern.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Kumusta ang imong {gap}? (Wie war dein Tag?) - Maayo {gap}. (Es geht.)',
|
||
gaps: 2
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['adlaw', 'ra']
|
||
},
|
||
explanation: '"adlaw" = Tag, "Maayo ra" = Es geht.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1, // gap_fill
|
||
title: 'Antworten auf Alltagsfragen',
|
||
instruction: 'Fülle die Lücken mit den richtigen Bisaya-Wörtern.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Unsa imong ginabuhat? (Was machst du?) - {gap} ko. (Ich arbeite.) | Kapoy {gap}. (Ich bin müde.)',
|
||
gaps: 2
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Nagtrabaho', 'ko']
|
||
},
|
||
explanation: '"Nagtrabaho ko" = Ich arbeite, "Kapoy ko" = Ich bin müde.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4, // transformation
|
||
title: 'Alltagssatz übersetzen',
|
||
instruction: 'Übersetze den Satz ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Ich bin glücklich',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Nalipay ko',
|
||
alternatives: ['Malipayon ko', 'Nalipay ako']
|
||
},
|
||
explanation: '"Nalipay ko" bedeutet "Ich bin glücklich" auf Bisaya.'
|
||
}
|
||
],
|
||
|
||
// Lektion 13: Alltagsgespräche - Teil 2
|
||
'Alltagsgespräche - Teil 2': [
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Wohin gehst du?"?',
|
||
instruction: 'Wähle die richtige Frage aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Wohin gehst du?" auf Bisaya?',
|
||
options: ['Asa ka padulong?', 'Kumusta ka?', 'Unsa imong ginabuhat?', 'Tagpila ni?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Asa ka padulong?" bedeutet "Wohin gehst du?" - "Asa" = wo/wohin, "padulong" = unterwegs nach.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wie sagt man "Was ist dein Plan?"?',
|
||
instruction: 'Wähle die richtige Frage aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Was ist dein Plan?" auf Bisaya?',
|
||
options: ['Unsa imong plano?', 'Asa ka padulong?', 'Unsa imong ngalan?', 'Kinsa ka?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Unsa imong plano?" bedeutet "Was ist dein Plan?" - "plano" = Plan.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet "Moadto ko sa balay"?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Moadto ko sa balay"?',
|
||
options: ['Ich gehe nach Hause', 'Ich gehe zur Arbeit', 'Ich gehe in die Schule', 'Ich gehe in die Kirche']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Moadto ko sa balay" bedeutet "Ich gehe nach Hause" - "balay" = Haus.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Was bedeutet "Moadto ko sa merkado"?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Moadto ko sa merkado"?',
|
||
options: ['Ich gehe zum Markt', 'Ich gehe nach Hause', 'Ich gehe in die Kirche', 'Ich gehe ins Krankenhaus']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Moadto ko sa merkado" bedeutet "Ich gehe zum Markt" - "merkado" = Markt.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1, // gap_fill
|
||
title: 'Fragen zum Weg vervollständigen',
|
||
instruction: 'Fülle die Lücken mit den richtigen Bisaya-Wörtern.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} ka padulong? (wo/wohin) | {gap} imong plano? (was)',
|
||
gaps: 2
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Asa', 'Unsa']
|
||
},
|
||
explanation: '"Asa" = wo/wohin, "Unsa" = was.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1, // gap_fill
|
||
title: 'Antworten auf Weg-Fragen',
|
||
instruction: 'Fülle die Lücken mit den richtigen Bisaya-Wörtern.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Moadto ko sa {gap}. (Haus) | Moadto ko sa {gap}. (Markt)',
|
||
gaps: 2
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['balay', 'merkado']
|
||
},
|
||
explanation: '"balay" = Haus, "merkado" = Markt.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4, // transformation
|
||
title: 'Weg-Satz übersetzen 1',
|
||
instruction: 'Übersetze den Satz ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Ich gehe nach Hause',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Moadto ko sa balay',
|
||
alternatives: ['Mo-uli ko', 'Moadto ko sa among balay']
|
||
},
|
||
explanation: '"Moadto ko sa balay" und "Mo-uli ko" können beide "Ich gehe nach Hause" bedeuten.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4, // transformation
|
||
title: 'Weg-Satz übersetzen 2',
|
||
instruction: 'Übersetze den Satz ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Ich gehe später zum Markt',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Moadto ko sa merkado unya',
|
||
alternatives: ['Adto ko sa merkado unya', 'Moadto ko sa merkado karon']
|
||
},
|
||
explanation: '"Moadto ko sa merkado unya" passt zum in dieser Lektion eingeführten Alltagswortschatz rund um Wege und Markt.'
|
||
}
|
||
],
|
||
|
||
// Woche 1 - Wiederholung (Lektion 9)
|
||
'Woche 1 - Wiederholung': [
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wiederholung: Wie sagt man "Wie geht es dir?"?',
|
||
instruction: 'Wähle die richtige Begrüßung aus.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Wie geht es dir?" auf Bisaya?',
|
||
options: ['Kumusta ka?', 'Maayo', 'Salamat', 'Palihug']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Kumusta ka?" ist die Standard-Begrüßung auf Bisaya.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wiederholung: Wie sagt man "Mutter" auf Bisaya?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Mutter" auf Bisaya?',
|
||
options: ['Nanay', 'Tatay', 'Kuya', 'Ate']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Nanay" bedeutet "Mutter" auf Bisaya.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wiederholung: Was bedeutet "Palangga taka"?',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Palangga taka"?',
|
||
options: ['Ich hab dich lieb', 'Danke', 'Guten Tag', 'Auf Wiedersehen']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Palangga taka" bedeutet "Ich hab dich lieb" - wärmer als "I love you" im Familienkontext.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wiederholung: Was fragt man mit "Nikaon ka?"?',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Nikaon ka?"?',
|
||
options: ['Hast du schon gegessen?', 'Wie geht es dir?', 'Danke', 'Bitte']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Nikaon ka?" bedeutet "Hast du schon gegessen?" - typisch fürsorglich auf den Philippinen.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Wiederholung: Wie sagt man "Ich verstehe nicht"?',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagt man "Ich verstehe nicht" auf Bisaya?',
|
||
options: ['Wala ko kasabot', 'Salamat', 'Maayo', 'Palihug']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Wala ko kasabot" bedeutet "Ich verstehe nicht".'
|
||
},
|
||
{
|
||
exerciseTypeId: 3,
|
||
title: 'Woche 1: Minisatz bauen',
|
||
instruction: 'Schreibe eine kurze Sequenz aus Begrüßung und Fürsorge.',
|
||
questionData: {
|
||
type: 'sentence_building',
|
||
question: 'Baue: "Wie geht es dir? Hast du schon gegessen?"',
|
||
tokens: ['Kumusta', 'ka', 'Nikaon', 'na', 'ka']
|
||
},
|
||
answerData: {
|
||
correct: ['Kumusta ka? Nikaon na ka?', 'Kumusta ka. Nikaon na ka?']
|
||
},
|
||
explanation: 'Hier kombinierst du zwei wichtige Muster aus Woche 1.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Woche 1: Dialog ergänzen',
|
||
instruction: 'Ergänze die passende liebevolle Reaktion.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Welche Antwort passt?',
|
||
dialog: ['A: Mingaw ko nimo.', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Palangga taka.',
|
||
correct: ['Palangga taka.']
|
||
},
|
||
explanation: 'Die Kombination klingt im Familienkontext warm und natürlich.'
|
||
})
|
||
],
|
||
|
||
// Woche 1 - Vokabeltest (Lektion 10)
|
||
'Woche 1 - Vokabeltest': [
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Vokabeltest: Kumusta',
|
||
instruction: 'Was bedeutet "Kumusta"?',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Kumusta"?',
|
||
options: ['Wie geht es dir?', 'Danke', 'Bitte', 'Auf Wiedersehen']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Kumusta" kommt von spanisch "¿Cómo está?" - "Wie geht es dir?"'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Vokabeltest: Lola',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Lola"?',
|
||
options: ['Großmutter', 'Großvater', 'Mutter', 'Vater']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Lola" = Großmutter, "Lolo" = Großvater.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Vokabeltest: Salamat',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Salamat"?',
|
||
options: ['Danke', 'Bitte', 'Entschuldigung', 'Gern geschehen']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Salamat" bedeutet "Danke".'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Vokabeltest: Lami',
|
||
instruction: 'Was bedeutet "Lami"?',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Lami"?',
|
||
options: ['Lecker', 'Viel', 'Gut', 'Schnell']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Lami" bedeutet "lecker" oder "schmackhaft" - wichtig beim Essen!'
|
||
},
|
||
{
|
||
exerciseTypeId: 2, // multiple_choice
|
||
title: 'Vokabeltest: Mingaw ko nimo',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet "Mingaw ko nimo"?',
|
||
options: ['Ich vermisse dich', 'Ich freue mich', 'Ich mag dich', 'Ich liebe dich']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Mingaw ko nimo" bedeutet "Ich vermisse dich".'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Woche 1: Situative Kurzantwort',
|
||
instruction: 'Reagiere passend auf die Situation.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Jemand fragt: "Kumusta ka?" Antworte kurz und höflich.',
|
||
keywords: ['maayo', 'salamat']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Maayo ko, salamat.',
|
||
keywords: ['maayo', 'salamat']
|
||
},
|
||
explanation: 'Eine kurze höfliche Antwort reicht hier völlig aus.'
|
||
})
|
||
],
|
||
|
||
'Besuch & Gastfreundschaft': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Gast hereinbitten',
|
||
instruction: 'Wähle die natürlichste Formulierung, um einen Gast hereinzubitten.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Ein Familiengast steht vor der Tür. Was sagst du zuerst?',
|
||
options: ['Sulod lang.', 'Magpahuway sa.', 'Pila ang plite?', 'Asa ang sakayan?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Sulod lang." bedeutet sinngemäß "Komm einfach rein."'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Gast setzen lassen',
|
||
instruction: 'Fülle die Lücke mit der passenden Einladung aus.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Sulod lang. {gap} sa.',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Lingkod']
|
||
},
|
||
explanation: '"Lingkod sa." bedeutet "Setz dich erst einmal."'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Gast begrüßen und platzieren',
|
||
instruction: 'Reagiere kurz und passend.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Begrüße einen Gast, bitte ihn herein und biete einen Sitzplatz an.',
|
||
keywords: ['sulod', 'lingkod']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Maayong adlaw. Sulod lang. Lingkod sa.',
|
||
keywords: ['sulod', 'lingkod']
|
||
},
|
||
explanation: 'Das ist ein kompaktes, sehr natürliches Besuchsmuster.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: '„Komm rein" auf Bisaya',
|
||
instruction: 'Wähle die passende Formulierung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet „Sulod lang"?',
|
||
options: ['Komm (einfach) rein', 'Geh nach Hause', 'Warte draußen', 'Wir gehen essen']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Sulod lang" lädt den Gast ein, hereinzukommen.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Einladung übersetzen',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Setz dich.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Lingkod sa.',
|
||
alternatives: ['Lingkod lang.', 'Palihug lingkod.']
|
||
},
|
||
explanation: '„Lingkod sa." ist eine häufige, kurze Aufforderung zum Hinsetzen.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Besuch höflich aufnehmen',
|
||
instruction: 'Ergänze die passende Begrüßung.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Was sagst du zuerst, wenn jemand ankommt?',
|
||
dialog: ['A: Maayong adlaw!', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Sulod lang.',
|
||
correct: ['Sulod lang.', 'Sulod lang diri.']
|
||
},
|
||
explanation: 'Nach der Begrüßung folgt oft die Einladung hereinzukommen.'
|
||
})
|
||
],
|
||
|
||
'Gesundheit im Alltag': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Nach Beschwerden fragen',
|
||
instruction: 'Wähle die passendste Frage bei Kopfweh.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Jemand wirkt krank. Wie fragst du nach Kopfweh?',
|
||
options: ['Sakit imong ulo?', 'Asa ang merkado?', 'Naa kay assignment?', 'Mubayad ko.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Sakit imong ulo?" fragt direkt nach Kopfschmerzen.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Fürsorge bei Krankheit',
|
||
instruction: 'Fülle die Lücke mit der passenden Fürsorgeformel.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Sakit imong ulo? {gap} sa.',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Magpahuway']
|
||
},
|
||
explanation: '"Magpahuway sa." heißt "Ruh dich erst einmal aus."'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Kranke Person versorgen',
|
||
instruction: 'Antworte kurz und fürsorglich.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Frage nach Schmerzen und biete Ruhe an.',
|
||
keywords: ['sakit', 'magpahuway']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Sakit imong ulo? Magpahuway sa.',
|
||
keywords: ['sakit', 'magpahuway']
|
||
},
|
||
explanation: 'Das Muster verbindet Frage und Fürsorge in einer natürlichen Miniszene.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Kopfschmerz erkennen',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet „sakit imong ulo"?',
|
||
options: ['Hast du Kopfschmerzen?', 'Hast du Hunger?', 'Bist du müde?', 'Hast du Zeit?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Ulo" ist der Kopf; die Frage zielt auf Kopfschmerzen.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Ruhe empfehlen',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Ruh dich aus.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Magpahuway sa.',
|
||
alternatives: ['Pahuway sa una.', 'Magpahuway una.']
|
||
},
|
||
explanation: '„Magpahuway sa." ist eine häufige Fürsorgeformel bei Krankheit.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Fürsorge anbieten',
|
||
instruction: 'Ergänze die passende Reaktion.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Jemand sagt, dass ihm schwindelig ist. Was antwortest du?',
|
||
dialog: ['A: Sakit akong ulo.', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Magpahuway sa.',
|
||
correct: ['Magpahuway sa.', 'Magpahuway sa una.']
|
||
},
|
||
explanation: 'Ruhe anzubieten passt oft als erste fürsorgliche Reaktion.'
|
||
})
|
||
],
|
||
|
||
'Unterwegs & Transport': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Nach der Haltestelle fragen',
|
||
instruction: 'Wähle die passende Transportfrage.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Du willst wissen, wo du ein Fahrzeug bekommst. Was fragst du?',
|
||
options: ['Asa ang sakayan?', 'Sulod lang.', 'Nikaon na ka?', 'Unsay gibati nimo?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"sakayan" meint den Ort oder das Fahrzeug zum Einsteigen.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Fahrtpreis ergänzen',
|
||
instruction: 'Fülle die Lücke mit dem passenden Wort.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Pila ang {gap}?',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['plite']
|
||
},
|
||
explanation: '"plite" ist der Fahrpreis.'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Transport klären',
|
||
instruction: 'Reagiere mit zwei kurzen Fragen.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Frage nach Haltestelle und Fahrpreis.',
|
||
keywords: ['sakayan', 'plite']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Asa ang sakayan? Pila ang plite?',
|
||
keywords: ['sakayan', 'plite']
|
||
},
|
||
explanation: 'Das ist ein typischer Minidialog für Alltag und Transport.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Fahrpreis',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was fragst du mit „Pila ang plite"?',
|
||
options: ['Wie viel kostet die Fahrt?', 'Wo fährt der Bus?', 'Wann kommt er?', 'Ist das der richtige Bus?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Plite" bezeichnet hier den Fahrpreis.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Haltestelle fragen',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Wo ist die Haltestelle?',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Asa ang sakayan?',
|
||
alternatives: ['Asa dapit ang sakayan?', 'Asa man ang sakayan?']
|
||
},
|
||
explanation: '„Asa ang sakayan?" fragt nach dem Ort zum Einsteigen.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Fahrt klären',
|
||
instruction: 'Ergänze die zweite Frage.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Du stehst am Straßenrand. Was fragst du als Nächstes?',
|
||
dialog: ['A: Asa ang sakayan?', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Pila ang plite?',
|
||
correct: ['Pila ang plite?', 'Tagpila ang plite?']
|
||
},
|
||
explanation: 'Oft folgt nach der Richtungsfrage die Preisfrage.'
|
||
})
|
||
],
|
||
|
||
'Kinder im Alltag': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Kind nach Essen fragen',
|
||
instruction: 'Wähle die natürlichste Frage an ein Kind.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie fragst du ein Kind, ob es schon gegessen hat?',
|
||
options: ['Nikaon na ang bata?', 'Pila ni tanan?', 'Asa ang porma?', 'Mubayad ko.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: 'Hier wird gezielt das Muster für das Kind im Alltag geübt.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Schulfrage ergänzen',
|
||
instruction: 'Fülle die Lücke mit dem passenden Schulwort.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Andam na ka sa {gap}?',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['eskwela']
|
||
},
|
||
explanation: '"eskwela" bedeutet Schule.'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Kind für Schule vorbereiten',
|
||
instruction: 'Reagiere fürsorglich und kurz.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Frage nach Essen und ob das Kind bereit für die Schule ist.',
|
||
keywords: ['nikaon', 'eskwela']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Nikaon na ka? Andam na ka sa eskwela?',
|
||
keywords: ['nikaon', 'eskwela']
|
||
},
|
||
explanation: 'Das verbindet Fürsorge und Schulroutine in einem kompakten Muster.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Schule auf Bisaya',
|
||
instruction: 'Wähle die richtige Übersetzung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet „eskwela"?',
|
||
options: ['Schule', 'Spielplatz', 'Arzt', 'Hausaufgabe']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Eskwela" ist das geläufige Wort für Schule.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Bereit für die Schule',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Bist du bereit für die Schule?',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Andam na ka sa eskwela?',
|
||
alternatives: ['Ready na ka sa eskwela?', 'Andam ka na sa eskwela?']
|
||
},
|
||
explanation: '„Andam na ka sa eskwela?" ist eine typische Eltern-Frage.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Kind morgens ansprechen',
|
||
instruction: 'Ergänze die nächste Frage.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Das Kind hat gefrühstückt. Was fragst du dann?',
|
||
dialog: ['A: Nikaon na ka?', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Andam na ka sa eskwela?',
|
||
correct: ['Andam na ka sa eskwela?', 'Andam ka na sa eskwela?']
|
||
},
|
||
explanation: 'Essen und Schulbereitschaft werden oft in einem Rutsch abgefragt.'
|
||
})
|
||
],
|
||
|
||
'Arzt & Termin': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Zum Arzt gehen',
|
||
instruction: 'Wähle die passende Arztformulierung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagst du: "Wir gehen zum Arzt"?',
|
||
options: ['Adto ta sa doktor.', 'Giinvite tika.', 'Bisita mo unya.', 'Magdula ta.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Adto ta sa doktor." ist die direkte, alltagstaugliche Form.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Terminfrage ergänzen',
|
||
instruction: 'Fülle die Lücke mit dem passenden Fremdwort.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Naa moy {gap}?',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['appointment']
|
||
},
|
||
explanation: '"appointment" wird im Alltag oft direkt verwendet.'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Arzttermin vorbereiten',
|
||
instruction: 'Antworte in zwei kurzen Sätzen.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Sage, dass ihr zum Arzt geht, und frage nach dem Termin.',
|
||
keywords: ['doktor', 'appointment']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Adto ta sa doktor. Naa moy appointment?',
|
||
keywords: ['doktor', 'appointment']
|
||
},
|
||
explanation: 'Das Muster verbindet Weg zum Arzt und Terminorganisation.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Arztbesuch',
|
||
instruction: 'Wähle die passende Formulierung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet „Adto ta sa doktor"?',
|
||
options: ['Wir gehen zum Arzt.', 'Wir gehen einkaufen.', 'Wir gehen schlafen.', 'Wir gehen spielen.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Doktor" wird im Alltag oft für Arzt oder Praxis verwendet.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Termin erfragen',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Habt ihr einen Termin?',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Naa moy appointment?',
|
||
alternatives: ['Naa mo appointment?', 'Aduna moy appointment?']
|
||
},
|
||
explanation: '„Appointment" wird im Cebuano oft direkt übernommen.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Vor der Praxis',
|
||
instruction: 'Ergänze die zweite Frage.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Ihr seid angekommen. Was fragst du als Nächstes?',
|
||
dialog: ['A: Adto ta sa doktor.', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Naa moy appointment?',
|
||
correct: ['Naa moy appointment?', 'Naa mo appointment?']
|
||
},
|
||
explanation: 'Ort und Termin gehören im Arztalltag zusammen.'
|
||
})
|
||
],
|
||
|
||
'Dialogtag - Familie & Planung': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Tagesplan eröffnen',
|
||
instruction: 'Wähle die Formulierung, mit der du die Tagesplanung eröffnest.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie fragst du in der Familie nach dem Plan für heute?',
|
||
options: ['Unsa atong plano karon?', 'Asa ang ATM?', 'Pila ang plite?', 'Salamat sa pag-anhi.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: 'Damit eröffnest du einen Familien- oder Organisationsdialog sehr natürlich.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Kind abholen ergänzen',
|
||
instruction: 'Fülle die Lücke mit dem passenden Verb aus.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} nato ang bata unya.',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Kuhaon']
|
||
},
|
||
explanation: '"Kuhaon nato" meint hier "wir holen ... später ab".'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Familie planen',
|
||
instruction: 'Reagiere in zwei bis drei kurzen Sätzen.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Frage nach dem Plan für heute, sage, dass ihr das Kind später abholt, und kündige an, danach heimzugehen.',
|
||
keywords: ['plano', 'bata', 'mouli']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Unsa atong plano karon? Kuhaon nato ang bata unya. Pagkahuman, mouli ta.',
|
||
keywords: ['plano', 'bata', 'mouli']
|
||
},
|
||
explanation: 'Das ist ein typisches zusammenhängendes Planungsmuster aus der Stabilisierungsphase.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Plan für heute',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was fragst du mit „Unsa atong plano karon"?',
|
||
options: ['Was ist unser Plan für heute?', 'Wo ist das Kind?', 'Wann ist Feierabend?', 'Wer kocht?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Karon" bezieht sich auf jetzt bzw. heute.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Kind abholen',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Wir holen das Kind später ab.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Kuhaon nato ang bata unya.',
|
||
alternatives: ['Kuhaon nato ang bata.', 'Unya kuhaon nato ang bata.']
|
||
},
|
||
explanation: '„Kuhaon nato" drückt aus, dass „wir holen … ab".'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Heimweg ankündigen',
|
||
instruction: 'Ergänze den letzten Satz.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Der Plan steht. Was sagst du zum Schluss?',
|
||
dialog: ['A: Kuhaon nato ang bata unya.', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Pagkahuman, mouli ta.',
|
||
correct: ['Pagkahuman, mouli ta.', 'Unya mouli ta.']
|
||
},
|
||
explanation: 'Nach dem Abholen folgt oft die Ankündigung des Heimwegs.'
|
||
})
|
||
],
|
||
|
||
'Fehlertraining - häufige Verwechslungen I': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Vergangenheit oder Zukunft',
|
||
instruction: 'Wähle die Formulierung für "Ich bin hingegangen".',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welche Form passt zur Vergangenheit?',
|
||
options: ['Niadto ko.', 'Moadto ko.', 'Palihug.', 'Pasayloa ko.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Niadto ko." bezieht sich auf Vergangenes, "Moadto ko." auf Zukünftiges.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Bitte oder Entschuldigung',
|
||
instruction: 'Wähle die Formulierung für eine Bitte.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welche Form bedeutet "Bitte"?',
|
||
options: ['Palihug.', 'Pasayloa ko.', 'Niadto ko.', 'Moadto ko.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Palihug." ist die Bitte, "Pasayloa ko." die Entschuldigung.'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Bitte und Entschuldigung trennen',
|
||
instruction: 'Antworte mit Bitte und Entschuldigung in der richtigen Reihenfolge.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Bitte zuerst höflich um Wiederholung und entschuldige dich danach.',
|
||
keywords: ['palihug', 'pasayloa']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Palihug ka mubalik. Pasayloa ko.',
|
||
keywords: ['palihug', 'pasayloa']
|
||
},
|
||
explanation: 'Das Fehlertraining soll genau solche nahen Alltagsformen sauber trennen.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Vergangenheit vs. Zukunft',
|
||
instruction: 'Wähle die Zukunftsform.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welcher Satz beschreibt etwas Zukünftiges?',
|
||
options: ['Moadto ko unya.', 'Niadto ko gahapon.', 'Nikaon ko.', 'Nakatulog ko.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Mo-" markiert hier die Zukunft; „Ni-" die Vergangenheit.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Bitte übersetzen',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Bitte.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Palihug.',
|
||
alternatives: ['Palihug nimo.', 'Palihug ko.']
|
||
},
|
||
explanation: '„Palihug" ist die Kurzform für höfliche Bitten.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Entschuldigung nach der Bitte',
|
||
instruction: 'Ergänze die zweite Äußerung.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Du hast zu schnell geantwortet. Was sagst du danach?',
|
||
dialog: ['A: Palihug ka mubalik.', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Pasayloa ko.',
|
||
correct: ['Pasayloa ko.', 'Pasensya.']
|
||
},
|
||
explanation: 'Nach einer Bitte kann eine kurze Entschuldigung folgen.'
|
||
})
|
||
],
|
||
|
||
'Abschlussprüfung - Gesamtpfad': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Gesamtpfad: Alltagssituation erkennen',
|
||
instruction: 'Wähle die passendste Reaktion.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Ihr müsst in die Stadt, habt einen Termin und jemand braucht Hilfe. Welche Formulierung passt am besten?',
|
||
options: ['Aduna mi appointment. Tabangan tika.', 'Sulod lang. Lingkod sa.', 'Magdula ta. Lingaw ka?', 'Palangga taka. Gimingaw ko nimo.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: 'Die Abschlussprüfung mischt bewusst mehrere Alltagsfelder.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Gesamtpfad: Kernmuster vervollständigen',
|
||
instruction: 'Fülle beide Lücken mit den passenden Wörtern.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Moadto mi sa {gap}. Aduna mi {gap}.',
|
||
gaps: 2
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['lungsod', 'appointment']
|
||
},
|
||
explanation: 'Das verbindet Weg, Ort und Terminorganisation.'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Gesamtpfad: Kompakte Abschlussreaktion',
|
||
instruction: 'Reagiere in drei kurzen Sätzen.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Sage, dass ihr in die Stadt fahrt, einen Termin habt und du helfen wirst.',
|
||
keywords: ['lungsod', 'appointment', 'tabangan']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Moadto mi sa lungsod. Aduna mi appointment. Tabangan tika.',
|
||
keywords: ['lungsod', 'appointment', 'tabangan']
|
||
},
|
||
explanation: 'Die Abschlussprüfung bündelt Weg, Organisation und Hilfe in einer letzten Miniszene.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Stadt und Termin',
|
||
instruction: 'Wähle die passende Kombination.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welche Formulierung passt zu „wir fahren in die Stadt und haben einen Termin"?',
|
||
options: ['Moadto mi sa lungsod. Aduna mi appointment.', 'Sulod lang. Lingkod sa.', 'Nikaon na ka? Kaon ta.', 'Asa ang CR?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: 'Weg in die Stadt und Termin werden oft zusammen genannt.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Hilfe anbieten',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Ich helfe dir.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Tabangan tika.',
|
||
alternatives: ['Tabangan ko ikaw.', 'Motabang ko nimo.']
|
||
},
|
||
explanation: '„Tabangan tika" ist eine direkte Hilfszusage.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Abschluss im Gesamtpfad',
|
||
instruction: 'Ergänze die Hilfszusage.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Jemand ist überfordert. Was sagst du?',
|
||
dialog: ['A: Aduna mi appointment.', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Tabangan tika.',
|
||
correct: ['Tabangan tika.', 'Motabang ko nimo.']
|
||
},
|
||
explanation: 'Hilfe rundet viele gemischte Alltagsszenen ab.'
|
||
})
|
||
],
|
||
|
||
'Einkaufen vertiefen': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Gesamtpreis erfragen',
|
||
instruction: 'Wähle die passendste Einkaufsfrage.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Du hast mehrere Dinge ausgesucht. Wie fragst du nach dem Gesamtpreis?',
|
||
options: ['Pila ni tanan?', 'Kapoy na ka?', 'Asa ang bata?', 'Tabangan tika.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Pila ni tanan?" fragt nach dem Gesamtpreis.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Menge ergänzen',
|
||
instruction: 'Fülle die Lücke mit dem passenden Mengenwort.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Pwede tulo ka{gap}?',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['buok']
|
||
},
|
||
explanation: '"buok" wird für zählbare Einzelstücke verwendet.'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Einkauf abschließen',
|
||
instruction: 'Reagiere passend beim Bezahlen.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Frage nach dem Gesamtpreis und sage dann, dass du es nimmst.',
|
||
keywords: ['tanan', 'kuhaon']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Pila ni tanan? Kuhaon na nako.',
|
||
keywords: ['tanan', 'kuhaon']
|
||
},
|
||
explanation: 'Das ist ein sehr alltagsnaher Miniabschluss beim Einkaufen.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Gesamtpreis',
|
||
instruction: 'Wähle die richtige Frage.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wofür steht „Pila ni tanan"?',
|
||
options: ['Wie viel kostet alles zusammen?', 'Wo ist die Kasse?', 'Haben Sie Wechselgeld?', 'Ist das frisch?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Tanan" meint hier alles bzw. den Gesamtbetrag.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Stückzahl nennen',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Drei Stück, bitte.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Tulo ka buok, palihug.',
|
||
alternatives: ['Tulo ka buok.', 'Tulo lang, palihug.']
|
||
},
|
||
explanation: '„Buok" zählt einzelne Stücke.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Kauf abschließen',
|
||
instruction: 'Ergänze die Entscheidung.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Der Preis passt. Was sagst du?',
|
||
dialog: ['A: Pila ni tanan?', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Kuhaon na nako.',
|
||
correct: ['Kuhaon na nako.', 'Kuhaon nako ni.']
|
||
},
|
||
explanation: '„Kuhaon na nako" signalisiert, dass du es nimmst.'
|
||
})
|
||
],
|
||
|
||
'Nachbarschaft & Besuche': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Bei Nachbarn vorbeischauen',
|
||
instruction: 'Wähle die passendste Aussage für einen Besuch bei Nachbarn.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagst du: "Wir waren bei den Nachbarn"?',
|
||
options: ['Niadto mi sa silingan.', 'Adto ta sa doktor.', 'Magdula ta.', 'Naa koy assignment.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"silingan" bedeutet Nachbar oder Nachbarschaft.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Einladung in die Nachbarschaft',
|
||
instruction: 'Fülle die Lücke mit dem passenden Besuchswort.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} mo unya.',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Bisita']
|
||
},
|
||
explanation: '"Bisita mo unya." lädt zu einem späteren Besuch ein.'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Nachbarschaftsbesuch ankündigen',
|
||
instruction: 'Reagiere in zwei kurzen Sätzen.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Sag, dass ihr bei den Nachbarn wart und dass sie später zu Besuch kommen können.',
|
||
keywords: ['silingan', 'bisita']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Niadto mi sa silingan. Bisita mo unya.',
|
||
keywords: ['silingan', 'bisita']
|
||
},
|
||
explanation: 'Das verbindet Begegnung und Einladung in einem natürlichen Nachbarschaftskontext.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Nachbar',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet „silingan"?',
|
||
options: ['Nachbar / Nachbarschaft', 'Geschäft', 'Polizei', 'Schule']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Silingan" bezeichnet die Nachbarschaft oder den Nachbarn.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Besuch einladen',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Komm später zu Besuch.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Bisita mo unya.',
|
||
alternatives: ['Bisita lang mo unya.', 'Adto ka unya bisita.']
|
||
},
|
||
explanation: '„Bisita mo unya" lädt zu einem späteren Besuch ein.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Nach dem Besuch',
|
||
instruction: 'Ergänze die Einladung.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Ihr seid bei den Nachbarn gewesen. Was sagt ihr zum Abschied?',
|
||
dialog: ['A: Niadto mi sa silingan.', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Bisita mo unya.',
|
||
correct: ['Bisita mo unya.', 'Balik mo unya bisita.']
|
||
},
|
||
explanation: 'Ein Gegenbesuch wird oft freundlich angekündigt.'
|
||
})
|
||
],
|
||
|
||
'Rollenspiel - Konflikt und Hilfe': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Konflikt ruhig eröffnen',
|
||
instruction: 'Wähle die höflichste Eröffnung für ein schwieriges Gespräch.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie leitest du ein Konfliktgespräch ruhig ein?',
|
||
options: ['Pwede nato istoryahan?', 'Pila ni tanan?', 'Sulod lang.', 'Nikaon na ka?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Pwede nato istoryahan?" ist weich und gesprächsorientiert.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Hilfe ergänzen',
|
||
instruction: 'Fülle die Lücke mit der passenden Hilfeformel.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} tika.',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Tabangan']
|
||
},
|
||
explanation: '"Tabangan tika." bedeutet "Ich helfe dir."'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Konflikt und Hilfe verbinden',
|
||
instruction: 'Reagiere kurz, höflich und lösungsorientiert.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Bitte darum, das Problem zu besprechen, und biete anschließend Hilfe an.',
|
||
keywords: ['istoryahan', 'tabangan']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Pwede nato istoryahan? Tabangan tika.',
|
||
keywords: ['istoryahan', 'tabangan']
|
||
},
|
||
explanation: 'Das Rollenspiel verbindet Deeskalation und konkrete Hilfe.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Gespräch eröffnen',
|
||
instruction: 'Wähle die weichste Eröffnung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet „Pwede nato istoryahan"?',
|
||
options: ['Können wir darüber sprechen?', 'Ich bin wütend.', 'Das interessiert mich nicht.', 'Geh weg.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Istoryahan" leitet ein Gespräch über ein Thema ein.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Hilfe zusagen',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Ich helfe dir gern.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Tabangan tika.',
|
||
alternatives: ['Motabang ko nimo.', 'Tabangan ko ikaw.']
|
||
},
|
||
explanation: 'Nach dem Gespräch kann eine klare Hilfszusage folgen.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Konflikt lösen',
|
||
instruction: 'Ergänze die Hilfe.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Das Problem ist benannt. Was bietest du an?',
|
||
dialog: ['A: Pwede nato istoryahan?', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Tabangan tika.',
|
||
correct: ['Tabangan tika.', 'Motabang ko nimo.']
|
||
},
|
||
explanation: 'Gespräch und Hilfe bilden oft eine Einheit.'
|
||
})
|
||
],
|
||
|
||
'Freies Sprechen - Alltag ohne Stütze': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Freies Sprechen strukturieren',
|
||
instruction: 'Wähle den Ausdruck, mit dem du eine freie Aussage natürlich einleitest.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welche Form passt gut als Einleitung für freies Sprechen?',
|
||
options: ['Sa tinuod...', 'Pila ang plite?', 'Asa ang sakayan?', 'Sulod lang.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Sa tinuod..." eignet sich gut, um frei in eine Aussage hineinzukommen.'
|
||
},
|
||
{
|
||
exerciseTypeId: 3,
|
||
title: 'Freie Aussage bauen',
|
||
instruction: 'Ordne die Wörter zu einer typischen Einleitung für eine freie Alltagsaussage.',
|
||
questionData: {
|
||
type: 'sentence_building',
|
||
question: 'Baue: "Meistens..."',
|
||
tokens: ['Kasagaran']
|
||
},
|
||
answerData: {
|
||
correct: ['Kasagaran...']
|
||
},
|
||
explanation: 'Diese Einleitungen helfen, im freien Sprechen in Gang zu kommen.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Einleitung „meistens"',
|
||
instruction: 'Wähle die passende Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was drückt „Kasagaran" aus?',
|
||
options: ['Meistens / in der Regel', 'Niemals', 'Nur heute', 'Vielleicht später']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Kasagaran" strukturiert freies Erzählen zeitlich.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Wahrheit einleiten',
|
||
instruction: 'Fülle die Lücke mit der passenden Einleitung.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap}... naghisgot ko kanimo.',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Sa tinuod']
|
||
},
|
||
explanation: '„Sa tinuod" leitet ehrliche Aussagen ein und passt zu freiem Sprechen.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Kontrast einbauen',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Aber manchmal bin ich müde.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Apan usahay kapoy ko.',
|
||
alternatives: ['Apan usahay kapoy ko gamay.', 'Apan kapoy usahay ko.']
|
||
},
|
||
explanation: '„Apan" und „usahay" verbinden Kontrast und Variation im freien Sprechen.'
|
||
},
|
||
{
|
||
title: 'Alltag frei erzählen',
|
||
instruction: 'Sprich ohne deutsche Stütze eine kurze freie Alltagsaussage.',
|
||
exerciseTypeId: 8,
|
||
questionData: {
|
||
type: 'speaking_from_memory',
|
||
question: 'Erzähle kurz frei über deinen Alltag und nutze mindestens zwei dieser Einleitungen: Sa tinuod, Kasagaran, Usahay, Apan.',
|
||
expectedText: 'Sa tinuod... Kasagaran... Usahay... Apan...',
|
||
keywords: ['tinuod', 'kasagaran', 'usahay', 'apan']
|
||
},
|
||
answerData: {
|
||
type: 'speaking_from_memory'
|
||
},
|
||
explanation: 'Hier geht es nicht mehr um perfekte Vorgabe, sondern um flüssige eigene Produktion.'
|
||
}
|
||
],
|
||
|
||
'Langzeitreview - Intensiv I': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Frühe Muster reaktivieren',
|
||
instruction: 'Wähle den Ausdruck, der sicher im Langzeitgedächtnis sitzen sollte.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welches frühe Fürsorgemuster musst du sofort wiedererkennen?',
|
||
options: ['Nikaon na ka?', 'Asa ang porma?', 'Naa moy appointment?', 'Mubayad ko.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: 'Das Langzeitreview holt sehr frühe Kernmuster bewusst wieder nach vorn.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Frühe Preisfrage ergänzen',
|
||
instruction: 'Fülle die Lücke mit dem passenden frühen Kernwort.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} ni?',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Tagpila']
|
||
},
|
||
explanation: '"Tagpila ni?" gehört zu den wichtigsten frühen Alltagsfragen.'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Frühe Routinen bündeln',
|
||
instruction: 'Reagiere mit zwei sehr frühen Kernmustern.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Begrüße jemanden kurz und frage dann, ob die Person schon gegessen hat.',
|
||
keywords: ['kumusta', 'nikaon']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Kumusta ka? Nikaon na ka?',
|
||
keywords: ['kumusta', 'nikaon']
|
||
},
|
||
explanation: 'Das reviewt ganz bewusst sehr frühe, sehr wichtige Sozialmuster.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Begrüßung reaktivieren',
|
||
instruction: 'Wähle die Standard-Begrüßung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welche Begrüßung gehört zu den frühesten Kernmustern?',
|
||
options: ['Kumusta ka?', 'Pila ang plite?', 'Asa ang merkado?', 'Naa moy assignment?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Kumusta ka?" öffnet fast jedes Gespräch.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Fürsorgefrage bilden',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Hast du schon gegessen?',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Nikaon na ka?',
|
||
alternatives: ['Kaon na ka?', 'Nikaon ka na?']
|
||
},
|
||
explanation: '„Nikaon na ka?" gehört zu den wichtigsten Fürsorgefragen.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Frühe Routine',
|
||
instruction: 'Ergänze die zweite Frage.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Du hast jemanden begrüßt. Was kommt oft als Nächstes?',
|
||
dialog: ['A: Kumusta ka?', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Nikaon na ka?',
|
||
correct: ['Nikaon na ka?', 'Kaon na ka?']
|
||
},
|
||
explanation: 'Begrüßung und Essensfrage sind ein klassisches Paar.'
|
||
})
|
||
],
|
||
|
||
'Langzeitreview - Intensiv II': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Frühe und späte Themen mischen',
|
||
instruction: 'Wähle den Ausdruck, der zum Reaktivieren späterer Alltagsfelder gehört.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welcher Ausdruck gehört klar zu Schule, Gesundheit oder Erledigungen?',
|
||
options: ['resibo', 'Kumusta ka?', 'Palangga taka.', 'Sulod lang.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"resibo" steht hier für spätere Erledigungs- und Alltagsblöcke.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Gesundheit reaktivieren',
|
||
instruction: 'Fülle die Lücke mit dem passenden Wort aus dem Gesundheitsbereich.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Adto ta sa {gap}.',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['doktor']
|
||
},
|
||
explanation: 'Auch späte Alltagsfelder sollen im Langzeitreview schnell wieder greifbar sein.'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Späte Themen bündeln',
|
||
instruction: 'Reagiere mit zwei kurzen Sätzen.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Sage, dass ihr zum Arzt geht, und erwähne danach ein Dokument oder einen Beleg.',
|
||
keywords: ['doktor', 'resibo']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Adto ta sa doktor. Naa ko resibo.',
|
||
keywords: ['doktor', 'resibo']
|
||
},
|
||
explanation: 'Das Langzeitreview mischt bewusst entfernte Themenfelder in einer kurzen Reaktion.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Beleg und Arzt',
|
||
instruction: 'Wähle die passende Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was ist ein „resibo" im Alltag?',
|
||
options: ['Kassenbon / Beleg', 'Rezept nur auf Deutsch', 'Arzthelfer', 'Terminbuch']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Resibo" wird oft für Quittung oder Beleg verwendet.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Zum Arzt gehen',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Wir gehen zum Arzt.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Adto ta sa doktor.',
|
||
alternatives: ['Moadto mi sa doktor.', 'Adto mi sa doktor.']
|
||
},
|
||
explanation: 'Arztbesuch und Belege werden oft in einer Szene kombiniert.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Nach dem Termin',
|
||
instruction: 'Ergänze den Satz zum Beleg.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Ihr wart beim Arzt. Was erwähnst du noch?',
|
||
dialog: ['A: Adto ta sa doktor.', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Naa ko resibo.',
|
||
correct: ['Naa ko resibo.', 'Naa koy resibo.']
|
||
},
|
||
explanation: 'Beleg und Besuch gehören in vielen Alltagsszenen zusammen.'
|
||
})
|
||
],
|
||
|
||
'Hilfe & Unterstützung': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Um Hilfe bitten',
|
||
instruction: 'Wähle die passendste Bitte um Unterstützung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie fragst du höflich, ob dir jemand helfen kann?',
|
||
options: ['Pwede ka motabang?', 'Asa ang sakayan?', 'Naa moy appointment?', 'Sulod lang.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Pwede ka motabang?" ist eine direkte, natürliche Hilfsbitte.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Hilfe anbieten ergänzen',
|
||
instruction: 'Fülle die Lücke mit der passenden Hilfsformel.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} tika.',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Tabangan']
|
||
},
|
||
explanation: '"Tabangan tika." bedeutet "Ich helfe dir."'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Hilfe erfragen und anbieten',
|
||
instruction: 'Reagiere in zwei kurzen Sätzen.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Bitte erst um Hilfe und bedanke dich danach kurz für die Unterstützung.',
|
||
keywords: ['tabang', 'salamat']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Pwede ka motabang? Salamat sa tabang.',
|
||
keywords: ['tabang', 'salamat']
|
||
},
|
||
explanation: 'Die Lektion verbindet Bitte und soziale Reaktion zu einem natürlichen Miniablauf.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Hilfe erkennen',
|
||
instruction: 'Wähle die richtige Frage.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie fragst du: „Kannst du helfen?"',
|
||
options: ['Pwede ka motabang?', 'Asa ang CR?', 'Tagpila ni?', 'Kapoy na ka?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Motabang" gehört zum Hilfsverb „tabang".'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Dank für Hilfe',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Danke für die Hilfe.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Salamat sa tabang',
|
||
alternatives: ['Salamat sa imong tabang', 'Daghang salamat sa tabang']
|
||
},
|
||
explanation: '„Salamat sa tabang" schließt Hilfsszenen höflich ab.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Hilfe und Dank',
|
||
instruction: 'Ergänze die Danksagung.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Jemand hat geholfen. Was sagst du?',
|
||
dialog: ['A: Tabangan tika.', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Salamat sa tabang.',
|
||
correct: ['Salamat sa tabang.', 'Daghang salamat.']
|
||
},
|
||
explanation: 'Hilfe und Dank bilden ein festes Paar.'
|
||
})
|
||
],
|
||
|
||
'Höflich reagieren und ablehnen': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Sanft ablehnen',
|
||
instruction: 'Wähle die höflichste weiche Absage.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie lehnst du etwas freundlich und nicht zu direkt ab?',
|
||
options: ['Dili lang sa karon.', 'Tabang!', 'Nikaon na ka?', 'Mubayad ko.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Dili lang sa karon." klingt deutlich weicher als ein hartes Nein.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Später statt jetzt',
|
||
instruction: 'Fülle die Lücke mit der passenden weichen Reaktion.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: '{gap} na lang.',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['Sunod']
|
||
},
|
||
explanation: '"Sunod na lang." verschiebt höflich auf später.'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Höflich verschieben',
|
||
instruction: 'Reagiere freundlich und weich.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Lehne eine Einladung höflich für heute ab und verschiebe sie auf später.',
|
||
keywords: ['dili', 'sunod']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Dili lang sa karon. Sunod na lang.',
|
||
keywords: ['dili', 'sunod']
|
||
},
|
||
explanation: 'Das ist genau die weiche soziale Reaktionsform dieser Lektion.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: '„Später" höflich',
|
||
instruction: 'Wähle die richtige Bedeutung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet „Sunod na lang"?',
|
||
options: ['Später eben / beim nächsten Mal', 'Niemals', 'Sofort', 'Gestern']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Sunod" verschiebt höflich auf einen späteren Zeitpunkt.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Höfliche Absage',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Nicht jetzt, bitte später.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Dili lang sa karon. Sunod na lang.',
|
||
alternatives: ['Dili karon. Sunod na lang.', 'Sunod na lang.']
|
||
},
|
||
explanation: 'Weiche Absage plus Verschiebung ist sehr typisch.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Einladung weich ablehnen',
|
||
instruction: 'Ergänze die Verschiebung.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Du kannst heute nicht. Was sagst du?',
|
||
dialog: ['A: Dili lang sa karon.', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Sunod na lang.',
|
||
correct: ['Sunod na lang.', 'Sunod na lang ha.']
|
||
},
|
||
explanation: 'Nach dem weichen Nein folgt oft ein späterer Vorschlag.'
|
||
})
|
||
],
|
||
|
||
'Feste & Einladungen': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Zur Feier einladen',
|
||
instruction: 'Wähle die passende Einladungsformel.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagst du: "Ich lade dich ein"?',
|
||
options: ['Giinvite tika.', 'Adto ta sa doktor.', 'Kapoy na ka?', 'Asa imong bag?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Giinvite tika." ist eine alltagsnahe Einladungsform.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Zur Fiesta fragen',
|
||
instruction: 'Fülle die Lücke mit dem passenden Wort.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Moadto ka sa {gap}?',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['pista']
|
||
},
|
||
explanation: '"pista" steht hier für Feier oder Fiesta.'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Einladung und Treffpunkt',
|
||
instruction: 'Reagiere in zwei kurzen Sätzen.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Lade jemanden ein und sage, dass ihr euch dort trefft.',
|
||
keywords: ['invite', 'didto']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Giinvite tika. Magkita ta didto.',
|
||
keywords: ['invite', 'didto']
|
||
},
|
||
explanation: 'Die Lektion verbindet Einladung und Verabredung in einer natürlichen Sozialszene.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Einladung',
|
||
instruction: 'Wähle die passende Formulierung.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Was bedeutet „Giinvite tika"?',
|
||
options: ['Ich lade dich ein.', 'Ich verabschiede mich.', 'Ich bin müde.', 'Ich zahle.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '„Giinvite" kommt von invite und wird umgangssprachlich genutzt.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Zur Fiesta',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Kommst du zur Fiesta?',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Moadto ka sa pista?',
|
||
alternatives: ['Adto ka sa pista?', 'Moadto ka ug pista?']
|
||
},
|
||
explanation: '„Pista" steht für Feier oder Fest.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Treffpunkt',
|
||
instruction: 'Ergänze den Ort.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Die Einladung steht. Was vereinbart ihr?',
|
||
dialog: ['A: Giinvite tika.', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Magkita ta didto.',
|
||
correct: ['Magkita ta didto.', 'Kitakit ta didto.']
|
||
},
|
||
explanation: '„Didto" markiert den Treffpunkt.'
|
||
})
|
||
],
|
||
|
||
'Freies Erzählen - Mein Alltag': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Tagesablauf einleiten',
|
||
instruction: 'Wähle die passendste Einleitung für einen Tagesablauf.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welche Formulierung passt gut als Start in einen erzählten Tagesablauf?',
|
||
options: ['Sa buntag...', 'Pila ni tanan?', 'Asa ang porma?', 'Sulod lang.']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Sa buntag..." eröffnet natürlich einen erzählten Tagesabschnitt.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Tagesabschnitt ergänzen',
|
||
instruction: 'Fülle die Lücke mit dem passenden Zeitabschnitt.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Sa {gap}...',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['hapon']
|
||
},
|
||
explanation: '"Sa hapon..." ist eine häufige Einleitung für den Nachmittag.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Abend einleiten',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Am Abend…',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Sa gabii...',
|
||
alternatives: ['Sa gabii.', 'Gabii...']
|
||
},
|
||
explanation: '„Sa gabii" strukturiert freies Erzählen am Tagesende.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Tagesablauf verknüpfen',
|
||
instruction: 'Ergänze den nächsten Tagesabschnitt.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Du hast den Morgen erzählt. Was folgt oft als Nächstes?',
|
||
dialog: ['A: Sa buntag...', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Sa hapon...',
|
||
correct: ['Sa hapon...', 'Unya sa hapon...']
|
||
},
|
||
explanation: 'Typischerweise wandert das Erzählen durch die Tageszeiten.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 3,
|
||
title: 'Kurzsätze verbinden',
|
||
instruction: 'Ordne die Marker zu einem kurzen Tagesabriss.',
|
||
questionData: {
|
||
type: 'sentence_building',
|
||
question: 'Baue: Morgen, Nachmittag, Abend.',
|
||
tokens: ['Sa buntag', 'Sa hapon', 'Sa gabii']
|
||
},
|
||
answerData: {
|
||
correct: ['Sa buntag... Sa hapon... Sa gabii...']
|
||
},
|
||
explanation: 'Drei Zeitmarker reichen oft als Gerüst fürs freie Erzählen.'
|
||
},
|
||
{
|
||
exerciseTypeId: 8,
|
||
title: 'Eigenen Alltag erzählen',
|
||
instruction: 'Sprich frei über deinen Tagesablauf.',
|
||
questionData: {
|
||
type: 'speaking_from_memory',
|
||
question: 'Erzähle kurz, was du morgens, nachmittags und abends machst.',
|
||
expectedText: 'Sa buntag... Sa hapon... Sa gabii...',
|
||
keywords: ['buntag', 'hapon', 'gabii']
|
||
},
|
||
answerData: {
|
||
type: 'speaking_from_memory'
|
||
},
|
||
explanation: 'Hier steht die freie, zusammenhängende Produktion im Vordergrund.'
|
||
}
|
||
],
|
||
|
||
'Freies Erzählen - Familie, Sorgen, Pläne': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Sorge ausdrücken',
|
||
instruction: 'Wähle die Formulierung, mit der du eine leichte Sorge ausdrückst.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Wie sagst du natürlich: "Ich bin etwas besorgt"?',
|
||
options: ['Naguol ko gamay.', 'Mubayad ko.', 'Sulod lang.', 'Tagpila ni?']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"Naguol ko gamay." drückt eine leichte Sorge oder Niedergeschlagenheit aus.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Plan ergänzen',
|
||
instruction: 'Fülle die Lücke mit dem passenden Planungswort.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Aduna koy {gap} unya.',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['plano']
|
||
},
|
||
explanation: '"plano" ist hier das Schlüsselwort für einen bevorstehenden Plan.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Beruhigung ausdrücken',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Aber es ist schon okay.',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Pero okay ra.',
|
||
alternatives: ['Pero okay lang.', 'Okay ra man.']
|
||
},
|
||
explanation: '„Pero okay ra" schließt Sorge und Zuversicht in einem Satz.'
|
||
},
|
||
withTypeName('dialog_completion', {
|
||
title: 'Sorge und Plan',
|
||
instruction: 'Ergänze den Plan.',
|
||
questionData: {
|
||
type: 'dialog_completion',
|
||
question: 'Du hast eine leichte Sorge genannt. Was kommt oft danach?',
|
||
dialog: ['A: Naguol ko gamay.', 'B: ...']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Aduna koy plano unya.',
|
||
correct: ['Aduna koy plano unya.', 'Naa koy plano unya.']
|
||
},
|
||
explanation: 'Nach Sorge folgt oft ein konkreter Plan.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 3,
|
||
title: 'Mini-Erzählung bauen',
|
||
instruction: 'Ordne zu einem kurzen emotionalen Bogen.',
|
||
questionData: {
|
||
type: 'sentence_building',
|
||
question: 'Baue: Sorge – aber okay – Plan.',
|
||
tokens: ['Naguol ko gamay.', 'Pero okay ra.', 'Aduna koy plano unya.']
|
||
},
|
||
answerData: {
|
||
correct: ['Naguol ko gamay. Pero okay ra. Aduna koy plano unya.']
|
||
},
|
||
explanation: 'Dieses Muster stützt freies Erzählen über Familie und Zukunft.'
|
||
},
|
||
{
|
||
exerciseTypeId: 8,
|
||
title: 'Familie, Sorge und Plan frei verbinden',
|
||
instruction: 'Sprich frei in mehreren kurzen Sätzen.',
|
||
questionData: {
|
||
type: 'speaking_from_memory',
|
||
question: 'Erzähle kurz von Familie, einer Sorge und einem Plan für später.',
|
||
expectedText: 'Naguol ko gamay. Pero okay ra. Aduna koy plano unya.',
|
||
keywords: ['naguol', 'okay', 'plano']
|
||
},
|
||
answerData: {
|
||
type: 'speaking_from_memory'
|
||
},
|
||
explanation: 'Diese Lektion trainiert freie Verbindung von Gefühl, Familie und Planung.'
|
||
}
|
||
],
|
||
|
||
'Kultur, Familie & Sprache langfristig': [
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Kulturellen Kernbegriff erkennen',
|
||
instruction: 'Wähle den Ausdruck, der stark mit respektvollem Umgang verbunden ist.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welcher Ausdruck gehört besonders zum kulturellen Schwerpunkt von Respekt und Rücksicht?',
|
||
options: ['respeto', 'plite', 'resibo', 'assignment']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"respeto" steht direkt für Respekt im sozialen Umgang.'
|
||
},
|
||
{
|
||
exerciseTypeId: 2,
|
||
title: 'Familienkultur und Sprache',
|
||
instruction: 'Wähle den Ausdruck, der besonders mit sozialem Miteinander verbunden ist.',
|
||
questionData: {
|
||
type: 'multiple_choice',
|
||
question: 'Welcher Begriff verweist besonders auf gemeinschaftliches Mitziehen und gutes Miteinander?',
|
||
options: ['pakikisama', 'doktor', 'ATM', 'sukli']
|
||
},
|
||
answerData: { type: 'multiple_choice', correctAnswer: 0 },
|
||
explanation: '"pakikisama" ist ein zentraler kultureller Begriff für harmonisches Miteinander.'
|
||
},
|
||
{
|
||
exerciseTypeId: 1,
|
||
title: 'Vorsicht und Rücksicht',
|
||
instruction: 'Fülle die Lücke mit dem passenden Kulturwort.',
|
||
questionData: {
|
||
type: 'gap_fill',
|
||
text: 'Mag-{gap} ta sa pamilya.',
|
||
gaps: 1
|
||
},
|
||
answerData: {
|
||
type: 'gap_fill',
|
||
answers: ['amping']
|
||
},
|
||
explanation: '„Mag-amping" drückt aus, vorsichtig und rücksichtsvoll mit der Familie umzugehen.'
|
||
},
|
||
{
|
||
exerciseTypeId: 4,
|
||
title: 'Bitte auf Bisaya',
|
||
instruction: 'Übersetze ins Bisaya.',
|
||
questionData: {
|
||
type: 'transformation',
|
||
text: 'Bitte (höflich)',
|
||
sourceLanguage: 'Deutsch',
|
||
targetLanguage: 'Bisaya'
|
||
},
|
||
answerData: {
|
||
type: 'transformation',
|
||
correct: 'Palihug',
|
||
alternatives: ['Palihug nimo.', 'Palihug ko.']
|
||
},
|
||
explanation: '„Palihug" gehört zu respektvollem Alltagston.'
|
||
},
|
||
withTypeName('situational_response', {
|
||
title: 'Respekt kurz zeigen',
|
||
instruction: 'Reagiere in einem kurzen Satz.',
|
||
questionData: {
|
||
type: 'situational_response',
|
||
question: 'Danke jemandem und betone Respekt und gutes Miteinander.',
|
||
keywords: ['salamat', 'respeto', 'pakikisama']
|
||
},
|
||
answerData: {
|
||
modelAnswer: 'Salamat. Respeto ug pakikisama.',
|
||
keywords: ['salamat', 'respeto', 'pakikisama']
|
||
},
|
||
explanation: 'Dank, Respekt und pakikisama lassen sich bewusst in einer Zeile verbinden.'
|
||
}),
|
||
{
|
||
exerciseTypeId: 8,
|
||
title: 'Kulturelle Schlüsselwörter laut festigen',
|
||
instruction: 'Sprich die kulturellen Schlüsselwörter laut und bewusst.',
|
||
questionData: {
|
||
type: 'speaking_from_memory',
|
||
question: 'Sprich die Wörter respeto, pakikisama, amping und palihug laut und deutlich.',
|
||
expectedText: 'respeto pakikisama amping palihug',
|
||
keywords: ['respeto', 'pakikisama', 'amping', 'palihug']
|
||
},
|
||
answerData: {
|
||
type: 'speaking_from_memory'
|
||
},
|
||
explanation: 'Die Schlusslektion verankert kulturelle Schlüsselwörter bewusst als Langzeitmarker.'
|
||
}
|
||
]
|
||
};
|
||
|
||
async function resolveExerciseTypeId(exercise) {
|
||
if (exercise.exerciseTypeId) {
|
||
return exercise.exerciseTypeId;
|
||
}
|
||
|
||
const trimmedName =
|
||
exercise.exerciseTypeName != null && exercise.exerciseTypeName !== ''
|
||
? String(exercise.exerciseTypeName).trim()
|
||
: '';
|
||
|
||
if (!trimmedName) {
|
||
throw new Error(`Kein exerciseTypeId oder exerciseTypeName für Übung "${exercise.title || 'unbenannt'}" definiert`);
|
||
}
|
||
|
||
const [type] = await sequelize.query(
|
||
`SELECT id FROM community.vocab_grammar_exercise_type WHERE name = :name LIMIT 1`,
|
||
{
|
||
replacements: { name: trimmedName },
|
||
type: sequelize.QueryTypes.SELECT
|
||
}
|
||
);
|
||
|
||
if (!type) {
|
||
throw new Error(`Übungstyp "${trimmedName}" nicht gefunden`);
|
||
}
|
||
|
||
return Number(type.id);
|
||
}
|
||
|
||
async function findOrCreateSystemUser() {
|
||
let systemUser = await User.findOne({
|
||
where: {
|
||
username: 'system'
|
||
}
|
||
});
|
||
|
||
if (!systemUser) {
|
||
systemUser = await User.findOne({
|
||
where: {
|
||
username: 'admin'
|
||
}
|
||
});
|
||
}
|
||
|
||
if (!systemUser) {
|
||
console.error('❌ System-Benutzer nicht gefunden.');
|
||
throw new Error('System user not found');
|
||
}
|
||
|
||
return systemUser;
|
||
}
|
||
|
||
function getExercisesForLesson(lesson) {
|
||
const lessonTitle = lesson.title;
|
||
// Suche nach exaktem Titel
|
||
if (BISAYA_EXERCISES[lessonTitle]) {
|
||
return BISAYA_EXERCISES[lessonTitle];
|
||
}
|
||
|
||
// Fallback: Suche nach Teilstring
|
||
for (const [key, exercises] of Object.entries(BISAYA_EXERCISES)) {
|
||
if (lessonTitle.includes(key) || key.includes(lessonTitle)) {
|
||
return exercises;
|
||
}
|
||
}
|
||
|
||
return generateExercisesFromDidactics(lesson);
|
||
}
|
||
|
||
async function createBisayaCourseContent() {
|
||
await sequelize.authenticate();
|
||
console.log('Datenbankverbindung erfolgreich hergestellt.\n');
|
||
const forceRebuildAll = process.env.VOCAB_FORCE_REBUILD_ALL === '1';
|
||
|
||
const systemUser = await findOrCreateSystemUser();
|
||
console.log(`Verwende System-Benutzer: ${systemUser.username} (ID: ${systemUser.id})\n`);
|
||
|
||
// Finde alle Bisaya-Kurse
|
||
const [bisayaLanguage] = await sequelize.query(
|
||
`SELECT id FROM community.vocab_language WHERE name = 'Bisaya' LIMIT 1`,
|
||
{
|
||
type: sequelize.QueryTypes.SELECT
|
||
}
|
||
);
|
||
|
||
if (!bisayaLanguage) {
|
||
console.error('❌ Bisaya-Sprache nicht gefunden.');
|
||
return;
|
||
}
|
||
|
||
const courses = await sequelize.query(
|
||
`SELECT id, title, owner_user_id AS "ownerUserId" FROM community.vocab_course WHERE language_id = :languageId`,
|
||
{
|
||
replacements: { languageId: bisayaLanguage.id },
|
||
type: sequelize.QueryTypes.SELECT
|
||
}
|
||
);
|
||
|
||
console.log(`Gefunden: ${courses.length} Bisaya-Kurse\n`);
|
||
|
||
let totalExercisesAdded = 0;
|
||
let totalLessonsProcessed = 0;
|
||
|
||
for (const course of courses) {
|
||
console.log(`📚 Kurs: ${course.title} (ID: ${course.id})`);
|
||
|
||
const lessons = await VocabCourseLesson.findAll({
|
||
where: { courseId: course.id },
|
||
order: [['lessonNumber', 'ASC']]
|
||
});
|
||
|
||
console.log(` ${lessons.length} Lektionen gefunden\n`);
|
||
|
||
for (const lesson of lessons) {
|
||
const exercises = getExercisesForLesson(lesson);
|
||
if (exercises.length === 0) {
|
||
const existingCount = await VocabGrammarExercise.count({ where: { lessonId: lesson.id } });
|
||
if (existingCount > 0) {
|
||
console.log(` ⏭️ Lektion ${lesson.lessonNumber}: "${lesson.title}" - bereits ${existingCount} Übung(en) vorhanden`);
|
||
} else {
|
||
console.log(` ⚠️ Lektion ${lesson.lessonNumber}: "${lesson.title}" - keine Übungen definiert`);
|
||
}
|
||
continue;
|
||
}
|
||
|
||
// Lektionen mit Platzhalter-Ersetzung: alte Übungen entfernen und durch echte ersetzen
|
||
const replacePlaceholders = [
|
||
'Woche 1 - Wiederholung',
|
||
'Woche 1 - Vokabeltest',
|
||
'Begrüßungen & Höflichkeit',
|
||
'Familienwörter',
|
||
'Essen & Fürsorge',
|
||
'Alltagsgespräche - Teil 1',
|
||
'Alltagsgespräche - Teil 2',
|
||
'Haus & Familie',
|
||
'Ort & Richtung',
|
||
'Zeitformen - Grundlagen',
|
||
'Zeit & Datum',
|
||
'Familie - Verwandte & Stieffamilie'
|
||
].includes(lesson.title);
|
||
const existingCount = await VocabGrammarExercise.count({
|
||
where: { lessonId: lesson.id }
|
||
});
|
||
|
||
if (existingCount > 0 && !replacePlaceholders && !forceRebuildAll) {
|
||
console.log(` ⏭️ Lektion ${lesson.lessonNumber}: "${lesson.title}" - bereits ${existingCount} Übung(en) vorhanden`);
|
||
continue;
|
||
}
|
||
|
||
if ((replacePlaceholders || forceRebuildAll) && existingCount > 0) {
|
||
const deleted = await VocabGrammarExercise.destroy({ where: { lessonId: lesson.id } });
|
||
const reason = forceRebuildAll ? 'vollständig neu aufgebaut' : 'Platzhalter entfernt';
|
||
console.log(` 🗑️ Lektion ${lesson.lessonNumber}: "${lesson.title}" - ${deleted} Übungen entfernt (${reason})`);
|
||
}
|
||
|
||
// Erstelle Übungen
|
||
const lessonDidactics = getLessonDidactics(lesson);
|
||
const mergedGrammarFocus = mergeGrammarFocusForLesson(
|
||
lessonDidactics.grammarFocus,
|
||
buildGrammarCurriculumFocus(lesson)
|
||
);
|
||
if (mergedGrammarFocus.length > 0) {
|
||
await lesson.update({ grammarFocus: mergedGrammarFocus });
|
||
}
|
||
const derivedCorePatterns = deriveLessonCorePatternsFromExercises(exercises);
|
||
const mergedCorePatterns = mergeCorePatternsForLesson(lessonDidactics, derivedCorePatterns, 8);
|
||
if (mergedCorePatterns.length >= 8) {
|
||
await lesson.update({ corePatterns: mergedCorePatterns });
|
||
if (process.env.VOCAB_STRICT_AUDIT === '1') {
|
||
console.log(` ✅ [${lesson.title}] corePatterns auf ${mergedCorePatterns.length} Satzphrasen aktualisiert`);
|
||
}
|
||
} else if (process.env.VOCAB_STRICT_AUDIT === '1') {
|
||
console.warn(
|
||
` ⚠️ [${lesson.title}] Nur ${mergedCorePatterns.length} Satzphrasen mit sicherer Gloss gefunden (Ziel: 8)`
|
||
);
|
||
}
|
||
let exerciseNumber = 1;
|
||
for (const exerciseData of exercises) {
|
||
const { exercise, fixes, warnings } = sanitizeExerciseForConsistency(
|
||
lesson,
|
||
exerciseData,
|
||
lessonDidactics
|
||
);
|
||
if (process.env.VOCAB_STRICT_AUDIT === '1') {
|
||
fixes.forEach((fix) => console.log(` 🛠️ ${fix}`));
|
||
warnings.forEach((warning) => console.warn(` ⚠️ ${warning}`));
|
||
}
|
||
if (process.env.VOCAB_STRICT_AUDIT === '1') {
|
||
const warnings = collectExerciseAuditWarnings(lesson.title, exercise, exerciseNumber);
|
||
warnings.forEach((warning) => console.warn(` ⚠️ ${warning}`));
|
||
}
|
||
const exerciseTypeId = await resolveExerciseTypeId(exercise);
|
||
await VocabGrammarExercise.create({
|
||
lessonId: lesson.id,
|
||
exerciseTypeId,
|
||
exerciseNumber: exerciseNumber++,
|
||
title: exercise.title,
|
||
instruction: exercise.instruction,
|
||
questionData: JSON.stringify(exercise.questionData),
|
||
answerData: JSON.stringify(exercise.answerData),
|
||
explanation: exercise.explanation,
|
||
createdByUserId: course.ownerUserId || systemUser.id
|
||
});
|
||
totalExercisesAdded++;
|
||
}
|
||
|
||
console.log(` ✅ Lektion ${lesson.lessonNumber}: "${lesson.title}" - ${exercises.length} Übung(en) erstellt`);
|
||
totalLessonsProcessed++;
|
||
}
|
||
|
||
console.log('');
|
||
}
|
||
|
||
console.log(`\n🎉 Zusammenfassung:`);
|
||
console.log(` ${totalLessonsProcessed} Lektionen bearbeitet`);
|
||
console.log(` ${totalExercisesAdded} Grammatik-Übungen erstellt`);
|
||
}
|
||
|
||
createBisayaCourseContent()
|
||
.then(() => {
|
||
sequelize.close();
|
||
process.exit(0);
|
||
})
|
||
.catch((error) => {
|
||
console.error('❌ Fehler:', error);
|
||
sequelize.close();
|
||
process.exit(1);
|
||
});
|