@jjlmoya/utils-sports 1.21.0 → 1.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-sports",
-    "version": "1.21.0",
+    "version": "1.23.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/entries.ts

@@ -16,6 +16,10 @@ export { tennisScoreKeeper } from './tool/tennisScoreKeeper/entry';
 export type { TennisScoreKeeperLocaleContent } from './tool/tennisScoreKeeper/entry';
 export { dartsScoreKeeper } from './tool/dartsScoreKeeper/entry';
 export type { DartsScoreKeeperLocaleContent } from './tool/dartsScoreKeeper/entry';
+export { padelScoreKeeper } from './tool/padelScoreKeeper/entry';
+export type { PadelScoreKeeperLocaleContent } from './tool/padelScoreKeeper/entry';
+export { streetballScoreKeeper } from './tool/streetballScoreKeeper/entry';
+export type { StreetballLocaleContent } from './tool/streetballScoreKeeper/entry';
 export { sportsCategory } from './category';
 import { basketScoreKeeper } from './tool/basketScoreKeeper/entry';
 import { footballScoreKeeper } from './tool/footballScoreKeeper/entry';
@@ -26,4 +30,6 @@ import { scoreKeeper } from './tool/scoreKeeper/entry';
 import { tournamentBracket } from './tool/tournamentBracket/entry';
 import { tennisScoreKeeper } from './tool/tennisScoreKeeper/entry';
 import { dartsScoreKeeper } from './tool/dartsScoreKeeper/entry';
-export const ALL_ENTRIES = [basketScoreKeeper, footballScoreKeeper, gymTracker, pingPongScoreKeeper, reactionTester, scoreKeeper, tournamentBracket, tennisScoreKeeper, dartsScoreKeeper];
+import { padelScoreKeeper } from './tool/padelScoreKeeper/entry';
+import { streetballScoreKeeper } from './tool/streetballScoreKeeper/entry';
+export const ALL_ENTRIES = [basketScoreKeeper, footballScoreKeeper, gymTracker, pingPongScoreKeeper, reactionTester, scoreKeeper, tournamentBracket, tennisScoreKeeper, dartsScoreKeeper, padelScoreKeeper, streetballScoreKeeper];

package/src/tests/locale_completeness.test.ts

@@ -3,6 +3,6 @@ import { ALL_TOOLS } from '../tools';
 
 describe('Locale Completeness Validation', () => {
   it('all tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(9);
+    expect(ALL_TOOLS.length).toBe(11);
   });
 });

package/src/tests/tool_validation.test.ts

@@ -4,8 +4,8 @@ import { sportsCategory } from '../data';
 
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
-    it('should have 9 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(9);
+    it('should have 11 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(11);
     });
 
     it('sportsCategory should be defined', () => {

package/src/tool/padelScoreKeeper/bibliography.astro

@@ -0,0 +1,15 @@
+---
+import { bibliography } from './bibliography';
+---
+
+<ul class="tn-bib-list">
+  {
+    bibliography.map((entry) => (
+      <li>
+        <a href={entry.url} target="_blank" rel="noopener noreferrer">
+          {entry.name}
+        </a>
+      </li>
+    ))
+  }
+</ul>

package/src/tool/padelScoreKeeper/bibliography.ts

@@ -0,0 +1,10 @@
+export const bibliography = [
+  {
+    name: 'FIP Padel Rules',
+    url: 'https://www.padelfip.com/wp-content/uploads/2025/12/FIP_Rules-of-Padel.pdf',
+  },
+  {
+    name: 'World Padel Tour Regulations',
+    url: 'https://www.padelfip.com/es/documents/',
+  },
+];

package/src/tool/padelScoreKeeper/component.astro

@@ -0,0 +1,142 @@
+---
+import type { KnownLocale } from '../../types';
+import type { PadelScoreKeeperUI } from './ui';
+
+interface Props {
+  locale?: KnownLocale;
+  ui?: Record<string, unknown>;
+}
+
+const { ui } = Astro.props;
+const t = (ui ?? {}) as PadelScoreKeeperUI;
+---
+
+<div class="tn-console" id="tn-card" data-tn-ui={JSON.stringify(t)}>
+  <div class="tn-header-panel">
+    <div class="tn-header-actions">
+      <button class="tn-action-btn" data-tn-reset title={t.reset}>
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+          <path d="M3 12a9 9 0 0 1 9-9 9.75 9.75 0 0 1 6.74 2.74L21 8"/>
+          <path d="M16 3h5v5M21 12a9 9 0 0 1-9 9 9.75 9.75 0 0 1-6.74-2.74L3 16"/>
+          <path d="M8 21H3v-5"/>
+        </svg>
+      </button>
+      <button class="tn-action-btn" data-tn-fs title={t.fullscreen}>
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+          <path d="M15 3h6v6M9 21H3v-6M21 3l-7 7M3 21l7-7"/>
+        </svg>
+      </button>
+    </div>
+  </div>
+
+  <div class="tn-scoreboard">
+    <div class="tn-player-card tn-player-card-active" id="tn-card-a">
+      <div class="tn-name-section">
+        <input type="text" value={t.playerA} class="tn-player-input" id="tn-name-a" />
+        <span class="tn-server-ball" id="tn-ball-a"></span>
+      </div>
+      <div class="tn-big-score" id="tn-score-a">0</div>
+      <div class="tn-sets-display" id="tn-sets-a"></div>
+    </div>
+
+    <div class="tn-player-card" id="tn-card-b">
+      <div class="tn-name-section">
+        <input type="text" value={t.playerB} class="tn-player-input" id="tn-name-b" />
+        <span class="tn-server-ball" id="tn-ball-b"></span>
+      </div>
+      <div class="tn-big-score" id="tn-score-b">0</div>
+      <div class="tn-sets-display" id="tn-sets-b"></div>
+    </div>
+  </div>
+
+  <div class="tn-court-panel">
+    <div class="tn-court-side-label tn-side-label-top" id="tn-court-label-top">{t.playerB}</div>
+    <div class="tn-court-wrapper">
+      <div class="tn-padel-court" id="tn-court">
+        <div class="tn-court-half tn-court-top" id="tn-court-half-b" data-court-half="top">
+          <div class="tn-court-quadrant tn-quad-left" data-quad-side="top" data-quad="left">
+            <div class="tn-quad-role tn-role-server">S</div>
+            <div class="tn-quad-role tn-role-receiver">R</div>
+          </div>
+          <div class="tn-court-quadrant tn-quad-right" data-quad-side="top" data-quad="right">
+            <div class="tn-quad-role tn-role-server">S</div>
+            <div class="tn-quad-role tn-role-receiver">R</div>
+          </div>
+        </div>
+        <div class="tn-net-line"></div>
+        <div class="tn-court-half tn-court-bottom" id="tn-court-half-a" data-court-half="bottom">
+          <div class="tn-court-quadrant tn-quad-left" data-quad-side="bottom" data-quad="left">
+            <div class="tn-quad-role tn-role-server">S</div>
+            <div class="tn-quad-role tn-role-receiver">R</div>
+          </div>
+          <div class="tn-court-quadrant tn-quad-right" data-quad-side="bottom" data-quad="right">
+            <div class="tn-quad-role tn-role-server">S</div>
+            <div class="tn-quad-role tn-role-receiver">R</div>
+          </div>
+        </div>
+        <svg class="tn-serve-arrow-svg" viewBox="0 0 200 300">
+          <path id="tn-serve-path" d="" fill="none" stroke="#cf0" stroke-width="3" stroke-dasharray="6,4" />
+        </svg>
+      </div>
+    </div>
+    <div class="tn-court-side-label tn-side-label-bottom" id="tn-court-label-bottom">{t.playerA}</div>
+  </div>
+
+  <div class="tn-action-controls">
+    <button class="tn-score-action-btn tn-score-btn-a" id="tn-btn-score-a">
+      <span class="tn-score-btn-lbl">+</span>
+      <span class="tn-score-btn-name" id="tn-btn-name-a">{t.playerA}</span>
+    </button>
+    <button class="tn-score-action-btn tn-score-btn-b" id="tn-btn-score-b">
+      <span class="tn-score-btn-lbl">+</span>
+      <span class="tn-score-btn-name" id="tn-btn-name-b">{t.playerB}</span>
+    </button>
+  </div>
+
+  <div class="tn-bottom-toolbar">
+    <button class="tn-toolbar-btn" data-dt-undo>Undo</button>
+    <div class="tn-control-group">
+      <button class="tn-control-btn tn-format-btn tn-format-active" data-dt-format="standard">{t.formatStandard}</button>
+      <button class="tn-control-btn tn-format-btn" data-dt-format="golden">{t.formatGoldenSet}</button>
+    </div>
+  </div>
+
+  <div id="tn-winner" class="tn-celebration-screen">
+    <div class="tn-celebration-box">
+      <svg class="tn-celebration-cup" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+        <path d="M6 9H4.5a2.5 2.5 0 0 1 0-5H6m12 5h1.5a2.5 2.5 0 0 0 0-5H18M6 4h12M12 18v3m-4 0h8m-4-17v14a4 4 0 0 1-4-4"/>
+      </svg>
+      <div class="tn-celebration-label">{t.matchWon}</div>
+      <div id="tn-winner-team" class="tn-celebration-name">Team 1</div>
+      <button class="tn-celebration-btn" data-close-winner>&times;</button>
+    </div>
+  </div>
+
+  <div id="tn-confetti" class="tn-confetti-field"></div>
+
+  <div id="tn-modal" class="tn-inline-modal">
+    <div class="tn-inline-modal-box">
+      <p class="tn-inline-modal-text">{t.resetConfirm}</p>
+      <div class="tn-inline-modal-btns">
+        <button id="tn-modal-cancel" class="tn-inline-modal-btn tn-inline-btn-cancel">{t.cancel}</button>
+        <button id="tn-modal-confirm" class="tn-inline-modal-btn tn-inline-btn-reset">{t.reset}</button>
+      </div>
+    </div>
+  </div>
+
+  <div id="tn-goldpoint-modal" class="tn-goldpoint-modal">
+    <div class="tn-goldpoint-box">
+      <div class="tn-goldpoint-title">{t.goldPointTitle}</div>
+      <div class="tn-goldpoint-desc">{t.selectReceiver}</div>
+      <div class="tn-goldpoint-btns">
+        <button class="tn-gp-btn" data-gp-side="left">{t.leftReceiver}</button>
+        <button class="tn-gp-btn" data-gp-side="right">{t.rightReceiver}</button>
+      </div>
+    </div>
+  </div>
+</div>
+
+<script>
+  import { initPadelScoreKeeper } from './logic';
+  initPadelScoreKeeper();
+</script>

package/src/tool/padelScoreKeeper/entry.ts

@@ -0,0 +1,30 @@
+import type { SportsToolEntry, ToolLocaleContent } from '../../types';
+import type { PadelScoreKeeperUI } from './ui';
+
+export type { PadelScoreKeeperUI };
+export type PadelScoreKeeperLocaleContent = ToolLocaleContent<PadelScoreKeeperUI>;
+
+export const padelScoreKeeper: SportsToolEntry<PadelScoreKeeperUI> = {
+  id: 'padel-scorekeeper',
+  icons: {
+    bg: 'mdi:tennis-ball',
+    fg: 'mdi:scoreboard-outline',
+  },
+  i18n: {
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    de: () => import('./i18n/de').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+  },
+};

package/src/tool/padelScoreKeeper/game-logic.ts

@@ -0,0 +1,160 @@
+export type TeamKey = 'a' | 'b';
+export type MatchFormat = 'standard' | 'golden';
+
+export interface TeamState {
+  score: string;
+  games: number;
+  sets: number[];
+  tiebreakPoints: number;
+}
+
+export interface PadelMatchState {
+  format: MatchFormat;
+  teamA: TeamState;
+  teamB: TeamState;
+  isTiebreak: boolean;
+  isSuperTiebreak: boolean;
+  isGoldPoint: boolean;
+  receiverSelectionSide: 'left' | 'right' | null;
+  serverTeam: TeamKey;
+  serverPosition: 'deuce' | 'ad';
+  endsSwapped: boolean;
+  winner: TeamKey | null;
+}
+
+export function createInitialTeam(): TeamState {
+  return {
+    score: '0',
+    games: 0,
+    sets: [],
+    tiebreakPoints: 0,
+  };
+}
+
+export function createInitialMatch(format: MatchFormat = 'standard'): PadelMatchState {
+  return {
+    format,
+    teamA: createInitialTeam(),
+    teamB: createInitialTeam(),
+    isTiebreak: false,
+    isSuperTiebreak: false,
+    isGoldPoint: false,
+    receiverSelectionSide: null,
+    serverTeam: 'a',
+    serverPosition: 'deuce',
+    endsSwapped: false,
+    winner: null,
+  };
+}
+
+function alternateServer(state: PadelMatchState): void {
+  state.serverTeam = state.serverTeam === 'a' ? 'b' : 'a';
+  state.serverPosition = 'deuce';
+}
+
+function checkEndsSwapAlert(state: PadelMatchState): boolean {
+  if (state.isTiebreak) {
+    const totalTbPoints = state.teamA.tiebreakPoints + state.teamB.tiebreakPoints;
+    return totalTbPoints > 0 && totalTbPoints % 6 === 0;
+  }
+  const totalGames = state.teamA.games + state.teamB.games;
+  return totalGames % 2 === 1;
+}
+
+function updateTiebreakServer(state: PadelMatchState): void {
+  const totalTb = state.teamA.tiebreakPoints + state.teamB.tiebreakPoints;
+  if (totalTb % 2 === 1) {
+    state.serverTeam = state.serverTeam === 'a' ? 'b' : 'a';
+    state.serverPosition = 'ad';
+  } else {
+    state.serverPosition = state.serverPosition === 'deuce' ? 'ad' : 'deuce';
+  }
+}
+
+function concludeSet(state: PadelMatchState): void {
+  state.teamA.sets.push(state.isTiebreak ? 7 : state.teamA.games);
+  state.teamB.sets.push(state.isTiebreak ? 6 : state.teamB.games);
+  state.teamA.games = 0;
+  state.teamB.games = 0;
+  state.teamA.tiebreakPoints = 0;
+  state.teamB.tiebreakPoints = 0;
+  state.isTiebreak = false;
+  state.isSuperTiebreak = false;
+  const setsWonA = state.teamA.sets.reduce((acc, v, idx) => acc + (v > state.teamB.sets[idx] ? 1 : 0), 0);
+  const setsWonB = state.teamB.sets.reduce((acc, v, idx) => acc + (v > state.teamA.sets[idx] ? 1 : 0), 0);
+  if (setsWonA >= 2) {
+    state.winner = 'a';
+  } else if (setsWonB >= 2) {
+    state.winner = 'b';
+  } else if (setsWonA === 1 && setsWonB === 1 && state.teamA.sets.length === 2) {
+    state.isSuperTiebreak = true;
+    state.isTiebreak = true;
+  }
+}
+
+function handleTiebreakPoint(state: PadelMatchState, winner: TeamKey): void {
+  const team = winner === 'a' ? state.teamA : state.teamB;
+  const other = winner === 'a' ? state.teamB : state.teamA;
+  team.tiebreakPoints += 1;
+  updateTiebreakServer(state);
+  const target = state.isSuperTiebreak ? 10 : 7;
+  if (team.tiebreakPoints >= target && team.tiebreakPoints - other.tiebreakPoints >= 2) {
+    concludeSet(state);
+  }
+}
+
+function handleGameWin(state: PadelMatchState, winner: TeamKey): void {
+  const team = winner === 'a' ? state.teamA : state.teamB;
+  const other = winner === 'a' ? state.teamB : state.teamA;
+  team.games += 1;
+  state.teamA.score = '0';
+  state.teamB.score = '0';
+  state.isGoldPoint = false;
+  state.receiverSelectionSide = null;
+  alternateServer(state);
+  const targetGames = state.format === 'golden' ? 4 : 6;
+  if (team.games >= targetGames && team.games - other.games >= 2) {
+    concludeSet(state);
+  } else if (team.games === targetGames && other.games === targetGames) {
+    state.isTiebreak = true;
+  }
+}
+
+export function processReceiverSelection(state: PadelMatchState, side: 'left' | 'right'): PadelMatchState {
+  const next = { ...state, teamA: { ...state.teamA }, teamB: { ...state.teamB } };
+  next.receiverSelectionSide = side;
+  return next;
+}
+
+function getNextScore(current: string): string {
+  if (current === '0') return '15';
+  if (current === '15') return '30';
+  return '40';
+}
+
+function handleStandardPoint(next: PadelMatchState, winner: TeamKey): void {
+  const team = winner === 'a' ? next.teamA : next.teamB;
+  if (team.score === '40') {
+    handleGameWin(next, winner);
+  } else {
+    team.score = getNextScore(team.score);
+  }
+  if (next.teamA.score === '40' && next.teamB.score === '40') {
+    next.isGoldPoint = true;
+  }
+  if (!next.isGoldPoint && next.teamA.score !== '0') {
+    next.serverPosition = next.serverPosition === 'deuce' ? 'ad' : 'deuce';
+  }
+}
+
+export function processPoint(state: PadelMatchState, winner: TeamKey): PadelMatchState {
+  if (state.winner) return state;
+  const next = JSON.parse(JSON.stringify(state)) as PadelMatchState;
+  if (next.isTiebreak) {
+    handleTiebreakPoint(next, winner);
+  } else {
+    handleStandardPoint(next, winner);
+  }
+  next.endsSwapped = checkEndsSwapAlert(next);
+  return next;
+}

package/src/tool/padelScoreKeeper/i18n/de.ts

@@ -0,0 +1,219 @@
+import { bibliography } from '../bibliography';
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { PadelScoreKeeperLocaleContent } from '../entry';
+
+const slug = 'padel-spielstand';
+const title = 'Premium Padel Spielstand : Gold Point & Aufschlagrotation';
+const description = 'Verfolge Padel-Punkte mit der offiziellen Punto de Oro (Gold Point) Regel, Aufschlagrotations-Alarmen, Tiebreaks und dynamischer Seitenwechsel-Animation.';
+
+const faq = [
+  {
+    question: 'Was ist der Gold Point (Punto de Oro) beim Padel?',
+    answer: 'Der Gold Point ist ein Entscheidungspunkt, der gespielt wird, wenn der Spielstand 40-40 (Einstand) erreicht. Es gibt kein Vorteilsspiel. Das aufschlagende Team wählt, ob es den Aufschlag auf der linken oder rechten Seite annimmt, und wer diesen einen Punkt gewinnt, gewinnt das gesamte Spiel.',
+  },
+  {
+    question: 'Wie funktionieren Satzformate beim Padel?',
+    answer: 'Standardspiele werden im Best-of-3-Sätzen ausgetragen, wobei jeder Satz vom ersten Team gewonnen wird, das 6 Spiele erreicht (mit 2 Spielen Vorsprung). Bei 6-6 wird ein 7-Punkte-Tiebreak gespielt. Ein optionales Golden-Set-Format endet bei 4 Spielen mit einem Tiebreak bei 4-4.',
+  },
+  {
+    question: 'Wann wechseln Spieler die Seiten beim Padel?',
+    answer: 'Die Spieler wechseln die Seiten nach dem ersten Spiel und dann alle 2 Spiele (wenn die Summe der Spiele im aktuellen Satz ungerade ist, z. B. 1, 3, 5). Während Tiebreaks wechseln die Spieler alle 6 Punkte die Seiten.',
+  },
+];
+
+const howTo = [
+  {
+    name: 'Satzformat konfigurieren',
+    text: 'Wähle das Standardformat (erster auf 6 Spiele) oder das kürzere Golden-Set-Format (erster auf 4 Spiele).',
+  },
+  {
+    name: 'Spielernamen eingeben',
+    text: 'Gib Teamnamen ein, um die Anzeigetafel zu personalisieren. Deine Einstellungen werden automatisch gespeichert.',
+  },
+  {
+    name: 'Punkte auf dem Platz erfassen',
+    text: 'Tippe auf eine Seite des visuellen isometrischen Padelplatzes, um Punkte zu erzielen. Aufschlaganzeiger führen dich durch die diagonalen Rotationen.',
+  },
+  {
+    name: 'Gold Points entscheiden',
+    text: 'Wenn der Einstand erreicht ist, wähle die Rückschlagseite (linker oder rechter Annahmespieler) und klicke auf das gewinnende Team, um das Spiel zu beenden.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faq.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howTo.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'SportsApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+  inLanguage: 'de',
+};
+
+export const content: PadelScoreKeeperLocaleContent = {
+  slug,
+  title,
+  description,
+  faq,
+  bibliography,
+  howTo,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Kostenlose Online Padel Anzeigetafel & Spielverfolgung',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Das Verfolgen der Punkte beim Padel kann mit schnellen Ballwechseln, Tiebreaks, Seitenwechseln und der offiziellen Punto de Oro (Gold Point) Regel verwirrend sein. Diese kostenlose Online-Padel-Anzeigetafel nimmt dir die Mühe der Punkteverfolgung ab. Tippe einfach auf das visuelle Spielfeld, um Punkte zu erfassen, und lass das Tool automatisch Aufschlagrotationen, Annahmeseiten, Satzverläufe und Seitenwechsel in Echtzeit verwalten.',
+    },
+    {
+      type: 'title',
+      text: 'Padel-Punktesystem, Gold Points und Rotationen verstehen',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Padel verwendet ein dem Tennis ähnliches Punktesystem (15, 30, 40, Spiel), führt aber spezifische Regeln für schnelleres Spiel ein. Nach den professionellen FIP-Regeln wird bei einem Spielstand von 40-40 ein entscheidender Gold Point (Punto de Oro) gespielt. Das annehmende Team wählt aus, welche Seite (links oder rechts) den Aufschlag erhält, und der Gewinner dieses einzigen Punktes gewinnt das Spiel. Außerdem müssen die Teams die Seiten wechseln, wenn die Gesamtzahl der Spiele in einem Satz ungerade ist, und alle 6 Punkte während eines Tiebreaks.',
+    },
+    {
+      type: 'comparative',
+      columns: 3,
+      items: [
+        {
+          title: 'Freundschaftsspiele',
+          description: 'Schnelle und saubere Punkteverfolgung für Freundschaftsspiele mit deinen Padel-Partnern.',
+          icon: 'mdi:tennis',
+          points: ['Punkte mit einem Klick', 'Optimiert für Mobilgeräte', 'Funktioniert offline'],
+        },
+        {
+          title: 'Verein & Liga',
+          description: 'Verfolge mühelos wettbewerbsorientierte Vereinsspiele und lokale Turniere.',
+          icon: 'mdi:trophy-outline',
+          points: ['Satzverlaufsarchiv', '6-Spiele oder 4-Spiele Sätze', 'Gold Point Unterstützung'],
+        },
+        {
+          title: 'Schiedsrichter Modus',
+          description: 'Voll ausgestattetes Tool zum Leiten offizieller Spiele oder Trainingseinheiten.',
+          icon: 'mdi:school',
+          points: ['Aktive Aufschlag- & Annahmemarker', 'Interaktive Platzrotation', 'Vollbild-Konsolenmodus'],
+        },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Erweiterte Digitale Funktionen für Padel-Spieler',
+      level: 2,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>Offizielle Gold Point Logik</strong> erlaubt dem annehmenden Team, die Annahmeseite bei Einstand zu wählen und zeigt den Aufschlagweg an.',
+        '<strong>Visueller Platzanzeiger</strong> zeigt die Positionen von Aufschläger (S) und Annahmespieler (R) dynamisch an, um Rotationsfehler zu vermeiden.',
+        '<strong>Automatischer Seitenwechsel</strong> dreht das Platzlayout bei ungeraden Spielen oder Tiebreak-Intervallen, damit es immer mit deiner physischen Ansicht übereinstimmt.',
+        '<strong>Anpassbare Satzformate</strong> unterstützt Standardsätze mit 6 Spielen oder schnelle Golden Sets mit 4 Spielen.',
+        '<strong>Lokale Browser-Autospeicherung</strong> bewahrt Spielernamen und aktuelle Spielstände, selbst wenn du die Seite aktualisierst.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Padel Tiebreak-Regeln: Standard vs. Super Tiebreak',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'In standardmäßigen Padel-Sätzen wird bei einem Spielstand von 6-6 ein 7-Punkte-Tiebreak gespielt. Bei einem Tiebreak werden die Punkte numerisch gezählt (1, 2, 3, usw.). Das erste Team, das 7 Punkte mit einem Vorsprung von 2 erreicht, gewinnt den Satz. Der Spieler, der an der Reihe ist aufzuschlagen, serviert den ersten Punkt von der rechten (Einstand-)Seite. Danach schlägt jeder Spieler zwei aufeinanderfolgende Punkte auf, beginnend von der linken (Vorteils-)Seite. In einigen Turnierformaten wird bei einem Satzstand von 1-1 ein 10-Punkte-Super-Tiebreak anstelle eines vollständigen dritten Satzes gespielt, um das Spiel zu entscheiden.',
+    },
+    {
+      type: 'title',
+      text: 'Platzwechsel und Rotationen: Fairness beim Padel',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Der Seitenwechsel ist beim Padel unerlässlich, um sicherzustellen, dass Umgebungsfaktoren wie Sonne, Wind oder platsspezifische Unebenheiten kein Team bevorzugen. Die Spieler müssen die Seiten nach dem ersten Spiel jedes Satzes und dann nach jeweils zwei Spielen wechseln (z. B. bei 1-0, 2-1, 3-2, 4-3, 5-4). Unsere digitale Padel-Anzeigetafel verfügt über eine dynamische Seitenwechsel-Animation, die das visuelle Platzlayout automatisch um 180 Grad dreht, wenn die Spieler physisch die Seiten wechseln müssen. Dadurch wird sichergestellt, dass das oben auf deinem Bildschirm angezeigte Team immer mit dem Team übereinstimmt, das am anderen Ende des physischen Platzes spielt.',
+    },
+    {
+      type: 'title',
+      text: 'Standard-Sätze vs. Golden Sets Format',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Während Standardspiele mit 6 Spielen pro Satz gespielt werden, verwenden viele Freizeitligen und schnelle Turniere das "Golden Set"-Format, bei dem Sätze nur bis 4 Spiele gespielt werden (mit Tiebreak bei 4-4). Diese Anzeigetafel ermöglicht es dir, mit einem einzigen Tipp in der Symbolleiste zwischen diesen Formaten zu wechseln. Unabhängig vom ausgewählten Format verwaltet die Anzeigetafel alle Tiebreaks, Aufschlagrotationen und Punkteberechnungen automatisch.',
+    },
+    {
+      type: 'title',
+      text: 'Tipps für effektive Punkteverfolgung auf dem Platz',
+      level: 2,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>Verwende einen Platzständer oder Handyhalter:</strong> Befestige dein Handy oder Tablet am Padelplatzzaun in Netzhöhe. So können Spieler auf beiden Seiten die aktuelle Punktzahl und die Aufschlaganzeiger leicht sehen.',
+        '<strong>Personalisiere Namen vor Spielbeginn:</strong> Nimm dir 10 Sekunden Zeit, um die tatsächlichen Namen der Spieler oder Teams einzugeben. Das macht die Sprachansagen (falls aktiviert) und die visuelle Anzeigetafel viel ansprechender und offizieller.',
+        '<strong>Aktiviere den Vollbildmodus:</strong> Klicke auf die Vollbild-Schaltfläche im Kopfbereich. Dies maximiert die Anzeigetafel-Oberfläche und verhindert, dass sich der Bildschirm bei langen Ballwechseln automatisch ausschaltet.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Warum einen digitalen Padel-Spielstand verwenden?',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Anstatt ständig darüber zu diskutieren, wer aufschlägt, wer an der Reihe ist anzunehmen oder wie der Spielstand ist, sorgt ein digitaler Spielstand dafür, dass alle auf dem gleichen Stand sind. Durch die visuelle Darstellung der Aufschläger- und Annahmepositionen direkt auf dem Bildschirm können die Spieler schnell auf das Handy auf der Bank schauen und genau wissen, wo sie stehen müssen. Das verbessert das Spieltempo und verhindert Rotationsfehler.',
+    },
+  ],
+  ui: {
+    playerA: 'Team 1',
+    playerB: 'Team 2',
+    game: 'Spiel',
+    set: 'Satz',
+    tiebreak: 'Tiebreak',
+    goldPoint: 'Gold Point',
+    selectReceiver: 'Annahmespieler wählen',
+    leftReceiver: 'Linker Annahmespieler',
+    rightReceiver: 'Rechter Annahmespieler',
+    server: 'Aufschläger',
+    receiver: 'Annahmespieler',
+    changeEnds: 'Seiten wechseln',
+    matchWon: 'Gewonnen',
+    reset: 'Zurücksetzen',
+    resetConfirm: 'Spiel zurücksetzen? Alle Daten gehen verloren.',
+    cancel: 'Abbrechen',
+    fullscreen: 'Vollbild',
+    exitFullscreen: 'Vollbild beenden',
+    deuce: 'Einstand',
+    advantage: 'Vorteil',
+    formatStandard: '6 Spiele',
+    formatGoldenSet: '4 Spiele',
+    goldenSet: 'Golden Set',
+    goldPointTitle: 'Gold Point Entscheidungspunkt',
+  },
+};