/* ============================================================
BAN YARO — Übungsbibliothek
Seiten-Modul: Grundkommandos, Tricks, Problemverhalten, Grundlagen.
============================================================ */
window.Page_uebungen = (() => {
let _container = null;
let _appState = null;
let _activeTab = 'grundkommandos';
// ----------------------------------------------------------
// API HELPERS
// ----------------------------------------------------------
function _dogId() {
return _appState?.activeDog?.id || null;
}
async function _apiPost(url, body) {
const r = await fetch(url, {
method: 'POST',
credentials: 'include',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify(body)
});
return r.ok ? r.json() : null;
}
async function _apiGet(url) {
const r = await fetch(url, {credentials: 'include'});
return r.ok ? r.json() : null;
}
// ----------------------------------------------------------
// STATS STATE
// ----------------------------------------------------------
let _helpHandle = null; // Rückgabe von UI.pageInfo — für inline Trigger-Button
let _statsData = null; // cached stats from /api/training/stats
let _badgesData = null; // cached badges from /api/achievements
let _exercisesByTab = {}; // aus API geladen
let _exercisesLoaded = false;
let _scrollTarget = null; // { exercise_id, name } — nach _renderContent() scrollen
let _searchQuery = ''; // aktuelle Sucheingabe
// ----------------------------------------------------------
// DATEN
// ----------------------------------------------------------
const TABS = [
{ id: 'grundkommandos', label: 'Grundkommandos' },
{ id: 'tricks', label: 'Tricks' },
{ id: 'problemverhalten', label: 'Problemverhalten' },
{ id: 'mentale-auslastung', label: 'Mentale Auslastung' },
{ id: 'hundesport', label: 'Hundesport' },
{ id: 'koerperpflege', label: 'Körperpflege' },
{ id: 'welpe-basics', label: 'Welpe Basics' },
{ id: 'grundlagen', label: 'Trainingsgrundlagen' },
{ id: 'ki-trainer', label: 'KI-Trainer' },
];
// ----------------------------------------------------------
// ÜBUNGS-STATUS
// ----------------------------------------------------------
const STATUS = [
{ id: null, icon: 'flag', color: 'var(--c-border)', label: 'Noch nicht geübt' },
{ id: 'noch-nicht', icon: 'x', color: 'var(--c-danger)', label: 'Klappt noch nicht' },
{ id: 'manchmal', icon: 'fire', color: '#f59e0b', label: 'Manchmal klappt es' },
{ id: 'meistens', icon: 'star', color: '#eab308', label: 'Meistens klappt es' },
{ id: 'sitzt', icon: 'trophy', color: 'var(--c-primary)', label: 'Sitzt!' },
];
function _statusKey(tab, name) {
return `ub_status_${tab}_${name.replace(/\s+/g, '_')}`;
}
// In-memory cache (loaded from API on init)
let _progressCache = {}; // key → statusId
let _exerciseStats = {}; // exercise_id → {recent_avg, session_count, trend}
function _progressKey(tab, name) {
return `${tab}_${name.replace(/[\s/]+/g, '_')}`;
}
function _getStatus(tab, name) {
const k = _progressKey(tab, name);
// Fallback to localStorage while API loads
return _progressCache[k] !== undefined
? _progressCache[k]
: localStorage.getItem(_statusKey(tab, name)) || null;
}
function _setStatus(tab, name, statusId) {
const k = _progressKey(tab, name);
_progressCache[k] = statusId;
localStorage.setItem(_statusKey(tab, name), statusId || ''); // keep localStorage in sync
API.training.setProgress(k, statusId).catch(() => {});
}
function _nextStatus(currentId) {
const idx = STATUS.findIndex(s => s.id === currentId);
const next = (idx + 1) % STATUS.length;
return STATUS[next].id;
}
function _statusMeta(statusId) {
return STATUS.find(s => s.id === statusId) || STATUS[0];
}
const DIFF_META = {
'Anfänger': { label: 'Anfänger', color: 'var(--c-success)' },
'Fortgeschrittener Anfänger': { label: 'Fortgeschr. Anfänger', color: '#eab308' },
'Mittel': { label: 'Mittel', color: 'var(--c-primary)' },
'Anfänger bis Fortgeschrittener': { label: 'Anfänger–Fortgeschr.', color: '#eab308' },
};
const GRUNDKOMMANDOS = [
{
name: 'Sitz',
schwierigkeit: 'Anfänger',
alter: 'Ab 8 Wochen',
dauer: '3–5 Minuten',
material: 'Leckerlis, ruhige Umgebung',
beschreibung: 'Der Hund setzt sich auf ein Signal hin. Das ist meist das erste Kommando und bildet die Basis für viele weitere Übungen.',
schritte: [
'Halte ein Leckerli knapp vor die Nase deines Hundes.',
'Führe das Leckerli langsam nach oben und leicht nach hinten über seinen Kopf.',
'Der Hund folgt mit der Nase — sein Hinterteil senkt sich automatisch.',
'Sobald er sitzt: sofort Markerwort ("Ja!" oder Klicker) + Leckerli.',
'Wiederhole 5–10x, bevor du das Wort "Sitz" hinzufügst.',
'Ab Wiederholung 10: Sage "Sitz" kurz bevor du die Handbewegung machst.',
],
fehler: [
'Leckerli zu hoch halten → Hund springt hoch statt zu sitzen',
'Kommando zu früh einführen → Hund lernt das Wort bevor er die Bewegung kennt',
'Zu lange Einheiten → Hund wird unkonzentriert',
],
steigerung: 'Sitz mit Ablenkung → Sitz aus Bewegung → Sitz auf Distanz',
},
{
name: 'Platz',
schwierigkeit: 'Anfänger',
alter: 'Ab 10 Wochen',
dauer: '3–5 Minuten',
material: 'Leckerlis, ruhige Umgebung',
beschreibung: 'Der Hund legt sich auf ein Signal hin. Wichtig für Ruhephasen, Wartesituationen und als Basis für "Bleib".',
schritte: [
'Beginne mit dem Hund im Sitz.',
'Halte ein Leckerli vor seine Nase und führe es langsam senkrecht nach unten zwischen seine Vorderpfoten.',
'Der Hund folgt mit der Nase und legt sich ab.',
'Sobald Ellenbogen und Hinterteil den Boden berühren: Markerwort + Leckerli.',
'Klappt es nicht: Leckerli unter ein angewinkeltes Knie halten — der Hund kriecht darunter durch und legt sich dabei ab.',
'Wort "Platz" erst nach 10–15 erfolgreichen Wiederholungen einführen.',
],
fehler: [
'Hund steht auf statt sich hinzulegen → Leckerli-Führung zu weit weg',
'Hund liegt nur kurz → zu früh belohnen, Dauer schrittweise aufbauen',
],
steigerung: 'Platz mit Dauer → Platz mit Distanz → Platz bei Ablenkung',
},
{
name: 'Bleib',
schwierigkeit: 'Anfänger bis Fortgeschrittener',
alter: 'Ab 12 Wochen',
dauer: '5 Minuten',
material: 'Leckerlis, Geduld',
beschreibung: 'Der Hund hält eine Position (Sitz oder Platz) bis er freigegeben wird. Drei Dimensionen: Dauer, Distanz, Ablenkung — immer nur eine auf einmal steigern.',
schritte: [
'Hund ins Sitz oder Platz bringen.',
'Einen Moment warten (2 Sekunden) → Markerwort + Leckerli.',
'Freigabewort einführen: "Okay" oder "Frei" — danach darf der Hund aufstehen.',
'Dauer schrittweise erhöhen: 2 → 5 → 10 → 30 Sekunden.',
'Erst wenn Dauer stabil ist: einen kleinen Schritt zurücktreten.',
'Zurückkehren zum Hund, belohnen — nicht den Hund zu dir kommen lassen.',
],
fehler: [
'Zu schnell Distanz aufbauen → Hund bricht ab',
'Hund wird zur Person gelobt statt an Ort → Hund kommt herangelaufen',
'Freigabewort vergessen → Hund weiß nicht wann er aufstehen darf',
],
steigerung: 'Bleib 1 Min → Bleib mit Sichtkontaktverlust → Bleib bei Ablenkung (Ball rollen, andere Person)',
},
{
name: 'Hier / Komm',
schwierigkeit: 'Anfänger',
alter: 'Ab 8 Wochen',
dauer: '5 Minuten',
material: 'Leckerlis oder Spielzeug, Schleppleine empfohlen',
beschreibung: 'Der Hund kommt zuverlässig zurück wenn er gerufen wird. Eines der wichtigsten Kommandos — im Zweifel lebensrettend.',
schritte: [
'Beginne in der Wohnung auf kurze Distanz (2–3 Meter).',
'Knie dich hin, öffne die Arme, freudige Stimme: "Hier!" oder "Komm!"',
'Sobald der Hund ankommt: große Freude, Leckerli, Streicheln.',
'Niemals rufen und dann etwas Unangenehmes tun (Bad, Krallen schneiden).',
'Im Garten: Schleppleine verwenden — Hund kann nicht wegbleiben, Erfolg ist garantiert.',
'Ruf nur einmal — wer mehrfach ruft trainiert den Hund aufs Ignorieren.',
],
fehler: [
'Hund rufen wenn er sicher nicht kommt → schlechte Gewohnheit',
'Hund bestrafen nach dem Kommen → nächstes Mal kommt er nicht',
'Monotone Stimme → Hund motiviert sich nicht',
],
steigerung: 'Kurze Distanz innen → Garten mit Schleppleine → Park mit wenig Ablenkung → Freilauf',
},
{
name: 'Fuß',
schwierigkeit: 'Fortgeschrittener Anfänger',
alter: 'Ab 12 Wochen',
dauer: '5–10 Minuten',
material: 'Leckerlis, Leine',
beschreibung: 'Der Hund läuft ruhig an der Leine neben dir, ohne zu ziehen. Die Leine hängt locker durch.',
schritte: [
'Hund an deine linke Seite stellen (klassisch), Leckerli in der linken Hand.',
'Einen Schritt vorwärts gehen, Leckerli auf Höhe deiner linken Hüfte halten.',
'Hund folgt dem Leckerli → Markerwort + belohnen.',
'Schrittweise mehr Schritte, immer wieder belohnen wenn Leine locker ist.',
'Zieht der Hund: stehen bleiben oder Richtung wechseln — nie mitziehen lassen.',
'Wort "Fuß" einführen sobald der Hund die Position versteht.',
],
fehler: [
'Leine straff halten → Hund lernt Zug als Normalzustand',
'Zu selten belohnen am Anfang → Hund verliert Interesse an der Position',
'Zu lange Einheiten → Überforderung',
],
steigerung: 'Fuß in der Wohnung → ruhige Straße → belebte Umgebung → ohne Leckerli in der Hand',
},
{
name: 'Aus / Lass es',
schwierigkeit: 'Anfänger',
alter: 'Ab 10 Wochen',
dauer: '3–5 Minuten',
material: 'Leckerlis, Spielzeug oder Gegenstand',
beschreibung: 'Der Hund lässt einen Gegenstand auf Kommando los. Wichtig für Sicherheit (Gefährliches fallen lassen) und Spielsituationen.',
schritte: [
'Gib dem Hund ein Spielzeug oder lass ihn etwas halten.',
'Halte ein Leckerli vor seine Nase — er lässt den Gegenstand fallen.',
'Sofort Markerwort + Leckerli geben.',
'Gegenstand kurz aufheben, dann wieder zurückgeben → Hund lernt: Loslassen lohnt sich.',
'Wort "Aus" kurz vor dem Leckerli-Zeigen einführen.',
],
fehler: [
'Gegenstand wegziehen → Hund lernt festhalten',
'Immer wegnehmen nach "Aus" → Hund gibt nicht mehr freiwillig her',
],
steigerung: 'Spielzeug → Leckerli auf dem Boden → Gegenstand unterwegs → hochwertige Beute',
},
{
name: 'Warte',
schwierigkeit: 'Anfänger',
alter: 'Ab 10 Wochen',
dauer: '3–5 Minuten',
material: 'Leckerlis, Türschwelle oder Futterschüssel',
beschreibung: 'Der Hund wartet kurz in einer Situation bis er freigegeben wird — z.B. vor der Tür, vor dem Futter, beim Aussteigen aus dem Auto.',
schritte: [
'Stelle die Futterschüssel auf den Boden — Hund stürmt drauf zu.',
'Schüssel mit der Hand abdecken oder hochhalten.',
'Sobald der Hund zurückweicht oder sitzt: Schüssel freigeben + "Okay".',
'Alternativ: an der Türschwelle — Tür öffnen, Hund wartet bis "Okay".',
'Wort "Warte" einführen sobald das Verhalten klar ist.',
],
fehler: [
'Hund wird nie freigegeben → verliert Vertrauen ins System',
'Zu lange warten lassen am Anfang → Frustration',
],
steigerung: null,
},
];
const TRICKS = [
{
name: 'Pfote / Schütteln',
schwierigkeit: 'Anfänger',
alter: 'Ab 12 Wochen',
dauer: '3 Minuten',
material: 'Leckerlis',
beschreibung: null,
schritte: [
'Hund ins Sitz bringen.',
'Leckerli in der Faust verstecken, Faust auf Kniehöhe halten.',
'Hund schnuppert, kratzt irgendwann mit der Pfote an der Faust.',
'Sofort öffnen: Markerwort + Leckerli.',
'Wort "Pfote" einführen sobald die Bewegung zuverlässig kommt.',
'Auf flache offene Hand umstellen → Hund legt Pfote rein.',
],
fehler: [],
steigerung: null,
},
{
name: 'Dreh / Runde',
schwierigkeit: 'Anfänger',
alter: 'Ab 12 Wochen',
dauer: '3–5 Minuten',
material: 'Leckerlis',
beschreibung: null,
schritte: [
'Leckerli vor die Nase des Hundes halten.',
'Langsam einen Kreis in der Luft führen — der Hund folgt mit der Nase.',
'Volle Drehung → Markerwort + Leckerli.',
'Wort "Dreh" (links) und "Runde" (rechts) einführen.',
'Handbewegung schrittweise kleiner machen.',
],
fehler: [],
steigerung: null,
},
{
name: 'Platz auf Decke / Matte',
schwierigkeit: 'Fortgeschrittener Anfänger',
alter: 'Ab 4 Monate',
dauer: '5–10 Minuten',
material: 'Leckerlis, Decke oder Matte',
beschreibung: 'Der Hund geht selbstständig auf seine Decke und legt sich. Ideal für Besuche, Restaurant, ruhige Phasen.',
schritte: [
'Decke auf den Boden legen. Hund beschnuppert sie → Leckerli auf die Decke werfen.',
'Jedes Mal wenn der Hund die Decke betritt: Markerwort + Leckerli.',
'Warten bis der Hund sich spontan auf die Decke legt → große Belohnung.',
'"Platz" zeigen sobald er auf der Decke steht.',
'Decke schrittweise weiter wegstellen.',
'Wort "Decke" oder "Platz geh" einführen.',
],
fehler: [],
steigerung: null,
},
{
name: 'Suchspiel / Nasenarbeit',
schwierigkeit: 'Anfänger',
alter: 'Ab 8 Wochen',
dauer: '5–10 Minuten',
material: 'Leckerlis, optional Döschen',
beschreibung: 'Nasenarbeit ist mentale Auslastung — 10 Minuten Suchen ermüdet mehr als 1 Stunde Spaziergang.',
schritte: [
'Leckerli vor den Augen des Hundes unter einem Becher verstecken.',
'Hund darf suchen → findet er es: Markerwort + Leckerli.',
'Steigerung: mehrere Becher, Hund muss den richtigen finden.',
'Später: Leckerlis im Gras verstecken → "Such!"',
'Noch später: Spielzeug oder Schlüssel suchen lassen.',
],
fehler: [],
steigerung: null,
},
];
const PROBLEMVERHALTEN = [
{
name: 'Nicht springen / Begrüßung',
schwierigkeit: 'Anfänger',
alter: 'Ab 8 Wochen',
dauer: 'Bei jeder Begrüßung',
material: 'Konsequenz aller Haushaltsmitglieder',
beschreibung: 'Der Hund begrüßt Menschen mit allen vier Pfoten auf dem Boden.',
schritte: [
'Springt der Hund hoch: keine Reaktion (kein "Nein", kein Wegdrücken, kein Augenkontakt).',
'Sobald alle vier Pfoten unten sind: sofort Markerwort + Leckerli + Aufmerksamkeit.',
'Konsequenz ist entscheidend — alle im Haushalt müssen gleich reagieren.',
'Alternative: Hund ins Sitz schicken bei Begrüßung → dann begrüßen.',
],
fehler: [],
steigerung: null,
},
{
name: 'Alleine bleiben',
schwierigkeit: 'Mittel',
alter: 'Ab 10 Wochen',
dauer: 'Mehrmals täglich kurze Einheiten',
material: 'Geduld, Zeit, Kong oder Kauartikel',
beschreibung: 'Der Hund bleibt ruhig wenn er allein ist — ohne Stress, Bellen oder Zerstören.',
schritte: [
'Hund beschäftigen (Kong mit Futter gefüllt, Kauartikel).',
'Zimmer verlassen für 10 Sekunden → zurückkommen, ruhig begrüßen.',
'Zeit schrittweise erhöhen: 30 Sek → 2 Min → 5 Min → 15 Min.',
'Nie dramatisch verabschieden oder begrüßen — Kommen und Gehen normalisieren.',
'Hund nicht bestrafen wenn er etwas angestellt hat — er versteht den Zusammenhang nicht mehr.',
],
fehler: [],
steigerung: null,
hinweis: 'Welpen sollten nie länger als 1–2 Stunden allein gelassen werden. Erwachsene Hunde maximal 4–6 Stunden.',
},
{
name: 'Leinenführigkeit — Nicht ziehen',
schwierigkeit: 'Mittel',
alter: 'Ab 12 Wochen',
dauer: 'Jeder Spaziergang',
material: 'Leine, Leckerlis, Geduld',
beschreibung: null,
schritte: [
'Beginne den Spaziergang ruhig — aufgeregte Starts fördern das Ziehen.',
'Zieht der Hund: stehen bleiben. Warten bis Leine locker ist.',
'Oder: Richtung wechseln sobald die Leine straff wird.',
'Locker Leine = Bewegung vorwärts + gelegentlich Leckerli.',
'Kein Ruck an der Leine — Hund lernt dadurch nicht.',
],
fehler: [],
steigerung: null,
hinweis: 'Hilfsmittel bei hartnäckigem Ziehen: Brustgeschirr mit vorderer Befestigung (kein Würge- oder Stachelband).',
},
{
name: 'Bellen / Kläffen',
schwierigkeit: 'Mittel',
alter: 'Ab 8 Wochen',
dauer: '5–10 Min täglich, konsequent',
material: 'Leckerlis, Geduld, Konsequenz',
beschreibung: 'Der Hund bellt nicht übermäßig auf Reize wie Klingel, Passanten oder andere Hunde — und beruhigt sich auf ein Signal hin.',
schritte: [
'Ursache kennen: Alarm-Bellen (Schutzinstinkt), Frust-Bellen (Leine, Zaun), Aufmerksamkeits-Bellen oder Angst-Bellen haben unterschiedliche Lösungswege.',
'Aufmerksamkeits-Bellen nie belohnen — auch nicht durch Zuwendung, Schimpfen oder Anfassen.',
'Signal „Ruhig" einführen: warten bis der Hund kurz pausiert, sofort markieren + belohnen.',
'Klingel / Türgeräusche: Reiz kontrolliert einüben (selbst klingeln), Hund ins Körbchen schicken und dort belohnen.',
'Bellt der Hund draußen auf Reize: Blickkontakt unterbrechen, Hund wegführen, Ablenkung mit Leckerli erst wenn er ruhig ist.',
'Ruhiges Verhalten konsequent belohnen — Hund lernt: Stille bringt Aufmerksamkeit, Bellen bringt nichts.',
],
fehler: [
'Schreien oder „Aus!"-Rufen während des Bellens — der Hund interpretiert es als Mitmachen.',
'Leckerli geben während der Hund noch bellt — das belohnt das Bellen.',
'Strafe: führt zu Angst, nicht zu weniger Bellen.',
],
steigerung: 'Reiz gezielt aufbauen (z.B. Klingel-Ton am Handy), erst in ruhiger Umgebung üben, dann mit echten Auslösern.',
hinweis: 'Anhaltend starkes Bellen kann auf Angst oder unerfüllte Bedürfnisse (Bewegung, Beschäftigung) hinweisen. Im Zweifel Verhaltensberater hinzuziehen.',
},
{
name: 'Enttriggern / Desensibilisierung',
schwierigkeit: 'Fortgeschrittener Anfänger',
alter: 'Ab 12 Wochen',
dauer: '5–15 Min, mehrmals wöchentlich',
material: 'Hochwertige Leckerlis, Geduld, Distanz',
beschreibung: 'Der Hund bleibt unter einem Reiz (Hund, Mensch, Geräusch, Fahrrad…) entspannt — kein Bellen, kein Zerren, keine Überreaktion.',
schritte: [
'Trigger identifizieren: Was genau löst die Reaktion aus? Ab welcher Distanz beginnt sie?',
'Schwellenabstand ermitteln: Die Entfernung, bei der der Hund den Reiz wahrnimmt aber noch nicht überreagiert — dort arbeiten.',
'Reiz zeigen → sofort hochwertiges Leckerli geben, bevor der Hund reagiert (Gegenkonditionierung: Reiz = super Sache).',
'Distanz ganz langsam verringern, nur wenn der Hund auf der aktuellen Stufe entspannt bleibt.',
'Reagiert der Hund doch: ruhig mehr Abstand schaffen, keine Strafe — er war schlicht zu nah.',
'Ziel: Hund schaut Trigger an und dreht sich dann entspannt zu dir um (Blickwechsel als Zeichen von Entspannung).',
],
fehler: [
'Zu schnell zu nah — der Hund gerät über die Reizschwelle und übt die Überreaktion ein.',
'Hund zwingen den Trigger anzuschauen oder ihm entgegenzugehen.',
'Training abbrechen wenn Hund bereits reagiert — lieber Abstand nehmen und neu ansetzen.',
],
steigerung: 'Erst mit einem einzelnen, vorhersehbaren Reiz üben. Dann wechselnde Reize, engere Distanz, schließlich Bewegung des Triggers.',
hinweis: 'Bei starker Reaktivität oder Aggression unbedingt mit einem zertifizierten Verhaltenstherapeuten (IAABC, BHV) zusammenarbeiten.',
},
];
// ----------------------------------------------------------
// INIT
// ----------------------------------------------------------
// DB-Kategorien → Tab-IDs
const _KAT_TO_TAB = {
'grundkommando': 'grundkommandos',
'grundkommandos': 'grundkommandos',
'trick': 'tricks',
'tricks': 'tricks',
'problemverhalten': 'problemverhalten',
'mentale auslastung': 'mentale-auslastung',
'mentale-auslastung': 'mentale-auslastung',
'hundesport': 'hundesport',
'körperpflege': 'koerperpflege',
'koerperpflege': 'koerperpflege',
'welpe basics': 'welpe-basics',
'welpe-basics': 'welpe-basics',
'grundlagen': 'grundlagen',
'ki-trainer': 'ki-trainer',
};
const _VALID_TABS = new Set(TABS.map(t => t.id));
async function init(container, appState, params = {}) {
_container = container;
_appState = appState;
// Tab aus exercise_id (JS-Format) oder kategorie ableiten
const exId = params.exercise_id || '';
if (exId) {
for (const [, tabId] of Object.entries(_KAT_TO_TAB)) {
if (exId.startsWith(tabId + '_') && _VALID_TABS.has(tabId)) {
_activeTab = tabId; break;
}
}
} else if (params.kategorie) {
const mapped = _KAT_TO_TAB[params.kategorie.toLowerCase()] || params.kategorie;
if (_VALID_TABS.has(mapped)) _activeTab = mapped;
}
_render();
_helpHandle = UI.pageInfo(_container, {
pageId: 'uebungen',
title: 'Übungsbibliothek',
icon: 'graduation-cap',
intro: 'Hier findest du alle Übungen für deinen Hund — von Grundkommandos bis zu Tricks und Problemverhalten. Du kannst deinen Trainingsfortschritt für jede Übung festhalten.',
steps: [
{ icon: 'list-checks', title: 'Stand erfassen', text: 'Klicke auf "Stand erfassen" um schnell für alle Übungen einzutragen, was euer aktueller Stand ist.' },
{ icon: 'flag', title: 'Übung üben', text: 'Tippe auf eine Übung, um die Anleitung zu lesen. Mit den Fortschritts-Icons (Flagge → Trophäe) trackst du, wie weit ihr seid.' },
{ icon: 'star', title: 'KI-Trainer', text: 'Im Tab "KI-Trainer" analysiert unsere KI deinen Trainingsstand und gibt personalisierte Empfehlungen.' },
],
tip: 'Regelmäßiges Training stärkt die Bindung — auch 5 Minuten täglich machen einen großen Unterschied!',
});
// Übungen aus DB laden (parallel mit Progress)
if (!_exercisesLoaded) {
API.get('/training/exercises').then(data => {
_exercisesByTab = data || {};
_exercisesLoaded = true;
_renderContent(); // neu rendern sobald Daten da
}).catch(() => {});
}
if (params.exercise_id || params.name) {
_scrollTarget = { exercise_id: params.exercise_id || '', name: params.name || '' };
}
// Progress vom Server laden
API.training.getProgress().then(rows => {
rows.forEach(r => { _progressCache[r.exercise_id] = r.status; });
// localStorage-Daten migrieren falls noch nicht im Backend
Object.keys(localStorage).filter(k => k.startsWith('ub_status_')).forEach(lsKey => {
const parts = lsKey.replace('ub_status_', '').split('_');
const tab = parts[0];
const name = parts.slice(1).join('_');
const apiKey = `${tab}_${name}`;
if (_progressCache[apiKey] === undefined) {
const val = localStorage.getItem(lsKey);
if (val) {
_progressCache[apiKey] = val;
API.training.setProgress(apiKey, val).catch(() => {});
}
}
});
_renderContent(); // Re-render with loaded progress
}).catch(() => {});
// Empfehlungen laden
API.training.getSuggestions().then(suggestions => {
if (suggestions.length) _showSuggestions(suggestions);
}).catch(() => {});
// Stats + Badges laden
_loadStatsAndBadges();
// Virtueller Trainer laden
_loadVirtualTrainer();
}
async function _loadStatsAndBadges() {
const dogId = _dogId();
if (!dogId) return;
const [stats, achievements] = await Promise.all([
_apiGet(`/api/training/stats?dog_id=${dogId}`),
_apiGet('/api/achievements'),
]);
_statsData = stats;
_badgesData = achievements;
_renderStatsBanner();
}
function refresh() {
if (!_VALID_TABS.has(_activeTab)) _activeTab = 'grundkommandos';
_renderContent();
}
function onDogChange() {
_statsData = null;
_badgesData = null;
_loadStatsAndBadges();
_loadVirtualTrainer();
}
// ----------------------------------------------------------
// HAUPT-RENDER
// ----------------------------------------------------------
function _render() {
_container.innerHTML = `
Ein Markerwort (z.B. "Ja!" oder ein Klicker) signalisiert dem Hund den exakten Moment
des richtigen Verhaltens. Es überbrückt die Zeit bis das Leckerli in seinem Mund ist.
${[
[true, 'Kurze Einheiten (5–10 Min), lieber mehrmals täglich'],
[true, 'Immer mit Erfolg beenden'],
[true, 'Ein Kommando — eine Bedeutung'],
[true, 'Konsequenz bei allen Haushaltsmitgliedern'],
[false, 'Nie bestrafen, schreien oder Zwang anwenden'],
[false, 'Kommando nicht wiederholen wenn der Hund nicht reagiert'],
[false, 'Nicht trainieren wenn Hund müde, krank oder aufgewühlt ist'],
].map(([ok, text]) => `