@jjlmoya/utils-games-development 1.61.0 → 1.63.0

package/src/tool/hitboxHurtboxAnimator/i18n/fr.ts

@@ -0,0 +1,195 @@
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { HitboxHurtboxAnimatorUI } from '../ui';
+import { bibliographyEntries } from '../bibliography';
+
+const slug = 'animateur-hitbox-hurtbox-sprites';
+const title = 'Animateur de Hitbox et Hurtbox pour Sprites';
+const description = 'Dessinez des calques de collision sur chaque image de sprite, prévisualisez les mouvements avec la pelure d\'oignon et exportez un fichier JSON neutre.';
+
+const faq = [
+  {
+    question: 'Quelle est la différence entre une hitbox et une hurtbox ?',
+    answer: 'Une hitbox définit la zone qui inflige une attaque, tandis qu\'une hurtbox définit la zone vulnérable qui la reçoit. Les pushboxes maintiennent les personnages à distance et les grabboxes définissent la portée des prises.',
+  },
+  {
+    question: 'Mes fichiers de sprites quittent-ils le navigateur ?',
+    answer: 'Non. Les images sont traitées et exportées entièrement dans votre navigateur. Seules les préférences d\'édition sont conservées localement.',
+  },
+  {
+    question: 'Quel système de coordonnées l\'export JSON utilise-t-il ?',
+    answer: 'Chaque image mesure ses coordonnées en pixels depuis le coin supérieur gauche du découpage. Les dimensions de largeur et hauteur stockent des valeurs positives avec leur propre pivot.',
+  },
+  {
+    question: 'Puis-je éditer une planche de sprites ou des images séparées ?',
+    answer: 'Oui. Vous pouvez charger une planche PNG ou WebP en indiquant les lignes et colonnes, ou sélectionner plusieurs images ordonnées.',
+  },
+  {
+    question: 'L\'export fonctionne-t-il directement dans tous les moteurs ?',
+    answer: 'Le format JSON est neutre. Il enregistre les rectangles d\'images, les pivots et les calques géométriques sans imposer un moteur spécifique.',
+  },
+];
+
+const howTo = [
+  { name: 'Charger les sprites', text: 'Sélectionnez une planche de sprites PNG/WebP ou des images ordonnées. Le traitement reste local.' },
+  { name: 'Définir les images', text: 'Indiquez le nombre de lignes et colonnes pour une planche et vérifiez le découpage sur le film d\'animation.' },
+  { name: 'Dessiner les calques de collision', text: 'Choisissez un calque hitbox, hurtbox, pushbox ou sensor, puis tracez un rectangle ou un cercle.' },
+  { name: 'Ajuster le mouvement', text: 'Modifiez les coordonnées exactes, copiez les formes sur les images voisines et utilisez la pelure d\'oignon.' },
+  { name: 'Exporter le projet', text: 'Téléchargez le fichier JSON neutre et une planche de contact PNG. Conservez les images d\'origine.' },
+];
+
+const softwareApplication: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  applicationCategory: 'DeveloperApplication',
+  operatingSystem: 'Any',
+};
+
+const faqPage: 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,
+  step: howTo.map((step) => ({ '@type': 'HowToStep', name: step.name, text: step.text })),
+};
+
+export const content: ToolLocaleContent<HitboxHurtboxAnimatorUI> = {
+  slug,
+  title,
+  description,
+  ui: {
+    onboarding: 'Chargez une animation, confirmez le découpage et dessinez les zones d\'attaque, de dégâts ou de collision.',
+    privacyNote: 'Table d\'animation locale. Les images ne sont pas envoyées sur un serveur.',
+    loadSprite: 'Placer l\'image sur la table d\'animation',
+    loadHint: 'Choisissez une planche de sprites ou des images PNG/WebP ordonnées.',
+    chooseImages: 'Choisir les images',
+    slicingTitle: 'Découpage des images',
+    rowsLabel: 'Lignes',
+    columnsLabel: 'Colonnes',
+    applySlicing: 'Découper',
+    playbackTitle: 'Aperçu du mouvement',
+    previousFrame: 'Image précédente',
+    play: 'Lecture',
+    pause: 'Pause',
+    nextFrame: 'Image suivante',
+    fpsLabel: 'Images par seconde',
+    onionPrevious: 'Calque précédent',
+    onionNext: 'Calque suivant',
+    layerTitle: 'Calques de collision',
+    typeHitbox: 'Hitbox',
+    typeHurtbox: 'Hurtbox',
+    typePushbox: 'Pushbox',
+    typeGrabbox: 'Grabbox',
+    typeSensor: 'Capteur',
+    typeCustom: 'Personnalisé',
+    shapeRectangle: 'Rectangle',
+    shapeCircle: 'Cercle',
+    drawShape: 'Dessiner',
+    selectShape: 'Sélectionner',
+    stageLabel: 'Zone de travail',
+    emptyStage: 'Chargez des images pour commencer à dessiner les calques de collision.',
+    frameReadout: 'Image {current} sur {total}',
+    timelineTitle: 'Bande d\'animation',
+    inspectorTitle: 'Inspecteur de forme',
+    noSelection: 'Sélectionnez une forme pour modifier ses coordonnées exactes.',
+    nameLabel: 'Nom du calque',
+    xLabel: 'X en pixels',
+    yLabel: 'Y en pixels',
+    widthLabel: 'Largeur en pixels',
+    heightLabel: 'Hauteur en pixels',
+    radiusLabel: 'Rayon en pixels',
+    duplicateShape: 'Dupliquer',
+    mirrorShape: 'Miroir horizontal',
+    deleteShape: 'Supprimer la forme',
+    copyPrevious: 'Copier l\'image précédente ici',
+    copyAll: 'Copier sur toutes les images',
+    pivotTitle: 'Pivot d\'image',
+    pivotXLabel: 'Pivot X',
+    pivotYLabel: 'Pivot Y',
+    exportTitle: 'Exporter le projet',
+    exportJson: 'Télécharger le JSON',
+    importJson: 'Importer un JSON',
+    exportContactSheet: 'Télécharger la planche de contact',
+    resetProject: 'Réinitialiser les calques',
+    undo: 'Annuler',
+    redo: 'Rétablir',
+    statusReady: 'La table d\'animation est prête.',
+    statusImageLoaded: '{count} fichiers d\'image chargés.',
+    statusShapeCreated: 'Forme de collision ajoutée.',
+    statusShapeUpdated: 'Forme mise à jour.',
+    statusImported: 'Projet importé.',
+    statusExported: 'Exportation prête.',
+    statusError: 'Impossible de lire le fichier sélectionné.',
+    framesBadge: '{count} images',
+    shapesBadge: '{count} formes',
+    coverageBadge: '{percent}% couvert',
+    coordinatesNote: 'Les coordonnées utilisent le coin supérieur gauche de chaque image comme origine (0,0).',
+    localOnlyDisclosure: 'Le fichier JSON stocke les noms d\'images, pivots et formes sans inclure les pixels.',
+    limitationDisclosure: 'Les calques définissent des zones géométriques. Testez-les directement dans votre moteur de jeu.',
+  },
+  seo: [
+    {
+      type: 'title',
+      level: 2,
+      text: 'Concevoir des hitboxes et hurtboxes adaptées au mouvement réel',
+    },
+    {
+      type: 'paragraph',
+      html: 'Régler les collisions devient complexe quand chaque image est analysée séparément. Cet éditeur rassemble l\'image du sprite, les calques de collision, la pelure d\'oignon et la chronologie pour garantir la continuité du mouvement.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Choisir chaque calque selon sa fonction dans le jeu',
+    },
+    {
+      type: 'table',
+      headers: ['Calque', 'Rôle principal', 'Question à vérifier'],
+      rows: [
+        ['Hitbox', 'Zone qui inflige une attaque ou un effet', 'Apparaît-elle uniquement pendant les images actives ?'],
+        ['Hurtbox', 'Zone qui reçoit une attaque', 'Suit-elle la silhouette sans écarts inutiles ?'],
+        ['Pushbox', 'Zone de collision physique entre personnages', 'Reste-t-elle stable pour éviter les secousses ?'],
+        ['Grabbox', 'Portée pour déclencher une prise', 'Le timing correspond-il à l\'animation visuelle ?'],
+        ['Sensor', 'Zone de détection pour les interactions', 'Le nom est-il suffisamment explicite ?'],
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Comprendre et appliquer le système de coordonnées',
+    },
+    {
+      type: 'paragraph',
+      html: 'Le projet exporté mesure X et Y depuis le coin supérieur gauche de chaque image découpée. Les dimensions sont positives et exprimées en pixels, facilitant la réutilisation dans votre moteur.',
+    },
+    {
+      type: 'tip',
+      title: 'Vérifier l\'ensemble de la séquence d\'attaque',
+      html: 'Relancez l\'animation complète après chaque modification pour valider la fluidité du geste.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Utiliser la planche de contact pour les revues d\'équipe',
+    },
+    {
+      type: 'paragraph',
+      html: 'La planche de contact PNG affiche toutes les images et leurs calques sur un seul visuel, idéal pour échanger entre graphistes et développeurs.',
+    },
+  ],
+  faq,
+  bibliographyTitle: 'Références sur la gestion des collisions',
+  bibliography: bibliographyEntries,
+  howTo,
+  schemas: [softwareApplication, faqPage, howToSchema],
+};

package/src/tool/hitboxHurtboxAnimator/i18n/id.ts

@@ -0,0 +1,195 @@
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { HitboxHurtboxAnimatorUI } from '../ui';
+import { bibliographyEntries } from '../bibliography';
+
+const slug = 'animator-hitbox-hurtbox-sprite';
+const title = 'Animator Hitbox dan Hurtbox Sprite';
+const description = 'Buat lapisan tabrakan pada setiap bingkai sprite, pratinjau animasi dengan fitur onion skin, sesuaikan koordinat piksel, dan ekspor JSON terstruktur.';
+
+const faq = [
+  {
+    question: 'Apa perbedaan antara hitbox dan hurtbox?',
+    answer: 'Hitbox menandai area serangan, sedangkan hurtbox menandai area yang dapat menerima serangan. Pushbox mengatur jarak antar karakter, grabbox menentukan jangkauan tangkapan, dan sensor berfungsi sebagai area deteksi.',
+  },
+  {
+    question: 'Apakah gambar sprite saya diunggah ke server?',
+    answer: 'Tidak. Seluruh pemrosesan gambar dilakukan di dalam peramban Anda. Alat ini hanya menyimpan pengaturan preferensi secara lokal.',
+  },
+  {
+    question: 'Sistem koordinat apa yang digunakan oleh ekspor JSON?',
+    answer: 'Setiap bingkai mengukur koordinat piksel dari sudut kiri atas. Nilai lebar, tinggi, dan posisi titik pivot disimpan dalam koordinat lokal.',
+  },
+  {
+    question: 'Bisakah saya mengedit lembaran sprite dan gambar bingkai terpisah?',
+    answer: 'Ya. Anda dapat memuat satu lembaran sprite PNG/WebP dengan mengatur jumlah baris dan kolom, atau memilih beberapa gambar berurutan.',
+  },
+  {
+    question: 'Apakah hasil ekspor dapat langsung digunakan di mesin game?',
+    answer: 'Format JSON bersifat netral dan dapat adaptasikan. Format ini menyimpan posisi kotak, titik pivot, dan bentuk geometri tanpa terikat pada mesin game tertentu.',
+  },
+];
+
+const howTo = [
+  { name: 'Muat gambar animasi', text: 'Pilih lembaran sprite PNG/WebP atau urutan gambar bingkai. Pemrosesan dilakukan secara lokal di perangkat Anda.' },
+  { name: 'Atur potong bingkai', text: 'Tentukan jumlah baris dan kolom untuk lembaran sprite dan periksa setiap bingkai pada bilah waktu.' },
+  { name: 'Gambar lapisan tabrakan', text: 'Pilih jenis hitbox, hurtbox, pushbox, atau sensor, lalu buat bentuk persegi atau lingkaran.' },
+  { name: 'Adjust gerakan animasi', text: 'Edit koordinat secara presisi, salin bentuk ke bingkai lain, dan gunakan onion skin untuk melihat animasi sebelumnya.' },
+  { name: 'Ekspor proyek JSON', text: 'Unduh berkas JSON dan lembaran kontak PNG. Simpan gambar asli bersama berkas JSON.' },
+];
+
+const softwareApplication: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  applicationCategory: 'DeveloperApplication',
+  operatingSystem: 'Any',
+};
+
+const faqPage: 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,
+  step: howTo.map((step) => ({ '@type': 'HowToStep', name: step.name, text: step.text })),
+};
+
+export const content: ToolLocaleContent<HitboxHurtboxAnimatorUI> = {
+  slug,
+  title,
+  description,
+  ui: {
+    onboarding: 'Muat animasi sprite, atur potongan bingkai, dan buat area serangan, area terkena dampak, atau area pergerakan fisika.',
+    privacyNote: 'Meja kerja lokal. Gambar tidak diunggah ke server.',
+    loadSprite: 'Muat gambar ke area kerja',
+    loadHint: 'Pilih satu lembaran sprite atau beberapa file PNG/WebP berurutan.',
+    chooseImages: 'Pilih gambar sprite',
+    slicingTitle: 'Pemotongan bingkai',
+    rowsLabel: 'Baris',
+    columnsLabel: 'Kolom',
+    applySlicing: 'Potong bingkai',
+    playbackTitle: 'Pratinjau gerakan',
+    previousFrame: 'Bingkai sebelumnya',
+    play: 'Putar',
+    pause: 'Jeda',
+    nextFrame: 'Bingkai berikutnya',
+    fpsLabel: 'Bingkai per detik',
+    onionPrevious: 'Lapisan sebelumnya',
+    onionNext: 'Lapisan berikutnya',
+    layerTitle: 'Lapisan tabrakan',
+    typeHitbox: 'Hitbox',
+    typeHurtbox: 'Hurtbox',
+    typePushbox: 'Pushbox',
+    typeGrabbox: 'Grabbox',
+    typeSensor: 'Sensor',
+    typeCustom: 'Kustom',
+    shapeRectangle: 'Persegi Panjang',
+    shapeCircle: 'Lingkaran',
+    drawShape: 'Gambar',
+    selectShape: 'Pilih',
+    stageLabel: 'Area animasi',
+    emptyStage: 'Muat gambar sprite untuk mulai membuat lapisan tabrakan.',
+    frameReadout: 'Bingkai {current} dari {total}',
+    timelineTitle: 'Bilah animasi',
+    inspectorTitle: 'Inspektur bentuk',
+    noSelection: 'Pilih bentuk untuk mengubah nilai koordinat secara presisi.',
+    nameLabel: 'Nama lapisan',
+    xLabel: 'X dalam piksel',
+    yLabel: 'Y dalam piksel',
+    widthLabel: 'Lebar dalam piksel',
+    heightLabel: 'Tinggi dalam piksel',
+    radiusLabel: 'Jari-jari dalam piksel',
+    duplicateShape: 'Duplikat',
+    mirrorShape: 'Cermin horizontal',
+    deleteShape: 'Hapus bentuk',
+    copyPrevious: 'Salin bingkai sebelumnya ke sini',
+    copyAll: 'Salin bingkai ini ke semua',
+    pivotTitle: 'Titik pivot',
+    pivotXLabel: 'Pivot X',
+    pivotYLabel: 'Pivot Y',
+    exportTitle: 'Ekspor proyek',
+    exportJson: 'Unduh JSON',
+    importJson: 'Impor JSON',
+    exportContactSheet: 'Unduh lembar kontak',
+    resetProject: 'Reset lapisan',
+    undo: 'Batal',
+    redo: 'Ulangi',
+    statusReady: 'Area kerja siap.',
+    statusImageLoaded: '{count} file gambar dimuat.',
+    statusShapeCreated: 'Bentuk tabrakan baru ditambahkan.',
+    statusShapeUpdated: 'Bentuk tabrakan diperbarui.',
+    statusImported: 'Proyek berhasil diimpor.',
+    statusExported: 'Berkas ekspor siap.',
+    statusError: 'File tidak dapat dibaca.',
+    framesBadge: '{count} bingkai',
+    shapesBadge: '{count} bentuk',
+    coverageBadge: '{percent}% cakupan',
+    coordinatesNote: 'Koordinat dihitung dari sudut kiri atas bingkai sebagai titik asal (0,0).',
+    localOnlyDisclosure: 'Berkas JSON menyimpan data bentuk dan titik pivot tanpa menyertakan data gambar.',
+    limitationDisclosure: 'Lapisan ini merupakan panduan geometri desain. Uji kembali di dalam mesin game Anda.',
+  },
+  seo: [
+    {
+      type: 'title',
+      level: 2,
+      text: 'Desain hitbox dan hurtbox sesuai dengan gerakan sprite',
+    },
+    {
+      type: 'paragraph',
+      html: 'Mengatur area tabrakan menjadi rumit jika setiap bingkai dianalisis secara terpisah. Alat ini menggabungkan tampilan sprite, lapisan tabrakan, dan alur animasi untuk memastikan konsistensi gerakan.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Pilih jenis lapisan sesuai dengan fungsi permainan',
+    },
+    {
+      type: 'table',
+      headers: ['Lapisan', 'Fungsi Utama', 'Hal yang Perlu Diperiksa'],
+      rows: [
+        ['Hitbox', 'Area yang menghasilkan serangan', 'Apakah hanya aktif pada bingkai yang tepat?'],
+        ['Hurtbox', 'Area yang menerima serangan', 'Apakah mengikuti bentuk karakter dengan pas?'],
+        ['Pushbox', 'Area tabrakan fisik antar karakter', 'Apakah ukurannya stabil agar tidak bergetar?'],
+        ['Grabbox', 'Jangkauan untuk tangkapan', 'Apakah waktunya sesuai dengan animasi visual?'],
+        ['Sensor', 'Area deteksi pemicu atau interaksi', 'Apakah namanya sudah cukup jelas?'],
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Memahami sistem koordinat bingkai',
+    },
+    {
+      type: 'paragraph',
+      html: 'Proyek JSON yang diekspor mengukur posisi X dan Y dari sudut kiri atas setiap bingkai. Nilai lebar dan tinggi disimpan dalam ukuran piksel asli.',
+    },
+    {
+      type: 'tip',
+      title: 'Periksa seluruh urutan gerakan animasi',
+      html: 'Putar animasi secara penuh setelah mengubah satu bingkai untuk memastikan alur gerakan tetap halus.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Gunakan lembaran kontak untuk peninjauan tim',
+    },
+    {
+      type: 'paragraph',
+      html: 'Lembaran kontak PNG menampilkan semua bingkai dan lapisan tabrakan dalam satu gambar untuk mempermudah komunikasi tim.',
+    },
+  ],
+  faq,
+  bibliographyTitle: 'Referensi desain area tabrakan',
+  bibliography: bibliographyEntries,
+  howTo,
+  schemas: [softwareApplication, faqPage, howToSchema],
+};

package/src/tool/hitboxHurtboxAnimator/i18n/it.ts

@@ -0,0 +1,195 @@
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { HitboxHurtboxAnimatorUI } from '../ui';
+import { bibliographyEntries } from '../bibliography';
+
+const slug = 'animatore-hitbox-hurtbox-sprite';
+const title = 'Animatore Hitbox e Hurtbox per Sprite';
+const description = 'Disegna livelli di collisione su ogni fotogramma dello sprite, anteprima con carta cipolla, modifica coordinate in pixel ed esporta JSON neutro.';
+
+const faq = [
+  {
+    question: 'Qual è la differenza tra hitbox e hurtbox?',
+    answer: 'Una hitbox definisce l area che infligge un attacco, mentre una hurtbox definisce l area vulnerabile che lo riceve. Le pushbox mantengono la distanza tra i personaggi e le grabbox regolano le prese.',
+  },
+  {
+    question: 'I miei file di immagini vengono caricati online?',
+    answer: 'No. Le immagini vengono elaborate ed esportate interamente nel tuo browser. Vengono salvate localmente solo le preferenze dell editor.',
+  },
+  {
+    question: 'Quale sistema di coordinate utilizza l esportazione JSON?',
+    answer: 'Ogni fotogramma misura le coordinate in pixel dall angolo in alto a sinistra. Le dimensioni di larghezza e altezza memorizzano valori positivi con il proprio perno.',
+  },
+  {
+    question: 'Posso modificare uno spritesheet o fotogrammi singoli?',
+    answer: 'Sì. Puoi caricare uno spritesheet PNG/WebP indicando righe e colonne, oppure selezionare più immagini ordinate.',
+  },
+  {
+    question: 'L esportazione funziona in tutti i motori di gioco?',
+    answer: 'Il formato JSON è neutro. Salva i rettangoli dei fotogrammi, i perni e i livelli geometrici senza imporre la struttura di un motore specifico.',
+  },
+];
+
+const howTo = [
+  { name: 'Carica la grafica', text: 'Seleziona uno spritesheet PNG/WebP o immagini ordinate. L elaborazione rimane locale sul tuo dispositivo.' },
+  { name: 'Definisci i fotogrammi', text: 'Imposta righe e colonne per uno spritesheet e verifica il ritaglio dei fotogrammi sulla sequenza temporale.' },
+  { name: 'Disegna i livelli di collisione', text: 'Scegli un livello hitbox, hurtbox, pushbox o sensore, quindi traccia un rettangolo o un cerchio.' },
+  { name: 'Rifinisci il movimento', text: 'Modifica le coordinate esatte, copia le forme su fotogrammi vicini e usa la carta cipolla.' },
+  { name: 'Esporta il progetto', text: 'Scarica il file JSON neutro e una scheda di contatto PNG. Conserva le immagini originali.' },
+];
+
+const softwareApplication: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  applicationCategory: 'DeveloperApplication',
+  operatingSystem: 'Any',
+};
+
+const faqPage: 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,
+  step: howTo.map((step) => ({ '@type': 'HowToStep', name: step.name, text: step.text })),
+};
+
+export const content: ToolLocaleContent<HitboxHurtboxAnimatorUI> = {
+  slug,
+  title,
+  description,
+  ui: {
+    onboarding: 'Carica un animazione, conferma i ritagli dei fotogrammi e disegna le aree di attacco, danno o collisione.',
+    privacyNote: 'Tavolo di animazione locale. Le immagini non vengono caricate online.',
+    loadSprite: 'Metti l immagine sul tavolo di lavoro',
+    loadHint: 'Scegli uno spritesheet o immagini PNG/WebP ordinate.',
+    chooseImages: 'Scegli immagini',
+    slicingTitle: 'Ritaglio fotogrammi',
+    rowsLabel: 'Righe',
+    columnsLabel: 'Colonne',
+    applySlicing: 'Ritaglia',
+    playbackTitle: 'Anteprima movimento',
+    previousFrame: 'Fotogramma precedente',
+    play: 'Riproduci',
+    pause: 'Pausa',
+    nextFrame: 'Fotogramma successivo',
+    fpsLabel: 'Fotogrammi al secondo',
+    onionPrevious: 'FOGLIO precedente',
+    onionNext: 'FOGLIO successivo',
+    layerTitle: 'Livelli di collisione',
+    typeHitbox: 'Hitbox',
+    typeHurtbox: 'Hurtbox',
+    typePushbox: 'Pushbox',
+    typeGrabbox: 'Grabbox',
+    typeSensor: 'Sensore',
+    typeCustom: 'Personalizzato',
+    shapeRectangle: 'Rettangolo',
+    shapeCircle: 'Cerchio',
+    drawShape: 'Disegna',
+    selectShape: 'Seleziona',
+    stageLabel: 'Area di lavoro',
+    emptyStage: 'Carica le immagini per iniziare a disegnare i livelli di collisione.',
+    frameReadout: 'Fotogramma {current} di {total}',
+    timelineTitle: 'Sequenza fotogrammi',
+    inspectorTitle: 'Ispettore forma',
+    noSelection: 'Seleziona una forma per modificarne le coordinate esatte.',
+    nameLabel: 'Nome livello',
+    xLabel: 'X in pixel',
+    yLabel: 'Y in pixel',
+    widthLabel: 'Larghezza in pixel',
+    heightLabel: 'Altezza in pixel',
+    radiusLabel: 'Raggio in pixel',
+    duplicateShape: 'Duplica',
+    mirrorShape: 'Rifletti orizzontalmente',
+    deleteShape: 'Elimina forma',
+    copyPrevious: 'Copia fotogramma precedente qui',
+    copyAll: 'Copia su tutti i fotogrammi',
+    pivotTitle: 'Perno fotogramma',
+    pivotXLabel: 'Perno X',
+    pivotYLabel: 'Perno Y',
+    exportTitle: 'Esporta progetto',
+    exportJson: 'Scarica JSON',
+    importJson: 'Importa JSON',
+    exportContactSheet: 'Scarica scheda di contatto',
+    resetProject: 'Ripristina livelli',
+    undo: 'Annulla',
+    redo: 'Ripristina',
+    statusReady: 'Il tavolo di lavoro è pronto.',
+    statusImageLoaded: '{count} file immagine caricati.',
+    statusShapeCreated: 'Forma di collisione aggiunta.',
+    statusShapeUpdated: 'Forma aggiornata.',
+    statusImported: 'Progetto importato.',
+    statusExported: 'Esportazione pronta.',
+    statusError: 'Impossibile leggere il file selezionato.',
+    framesBadge: '{count} fotogrammi',
+    shapesBadge: '{count} forme',
+    coverageBadge: '{percent}% coperto',
+    coordinatesNote: 'Le coordinate usano l angolo in alto a sinistra di ogni fotogramma come origine (0,0).',
+    localOnlyDisclosure: 'Il file JSON memorizza nomi delle immagini, perni e forme senza includere i pixel.',
+    limitationDisclosure: 'I livelli definiscono aree geometriche di design. Testali direttamente nel tuo motore di gioco.',
+  },
+  seo: [
+    {
+      type: 'title',
+      level: 2,
+      text: 'Progetta hitbox e hurtbox allineate al movimento reale dello sprite',
+    },
+    {
+      type: 'paragraph',
+      html: 'Configurare le collisioni risulta complesso quando ogni fotogramma viene analizzato singolarmente. Questo editor unisce l immagine dello sprite, i livelli di collisione, la carta cipolla e la sequenza temporale per garantire la fluidità del movimento.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Scegli ogni livello in base alla funzione di gioco',
+    },
+    {
+      type: 'table',
+      headers: ['Livello', 'Ruolo principale', 'Aspetto da verificare'],
+      rows: [
+        ['Hitbox', 'Area che infligge un attacco o effetto', 'Compare solo nei fotogrammi attivi previsti?'],
+        ['Hurtbox', 'Area che riceve attacchi o danni', 'Segue la silhouette senza spazi innaturali?'],
+        ['Pushbox', 'Area di collisione fisica tra personaggi', 'Rimani stabile per evitare scatti visibili?'],
+        ['Grabbox', 'Raggio d azione per avviare una presa', 'Il timing corrisponde all animazione visiva?'],
+        ['Sensor', 'Area di rilevamento per interazioni', 'Il nome è abbastanza chiaro per l implementazione?'],
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Comprendere e applicare il sistema di coordinate',
+    },
+    {
+      type: 'paragraph',
+      html: 'Il progetto esportato misura X e Y dall angolo in alto a sinistra di ogni fotogramma ritagliato. Le dimensioni di larghezza e altezza sono valori positivi espressi in pixel.',
+    },
+    {
+      type: 'tip',
+      title: 'Verifica l intera sequenza di attacco',
+      html: 'Riproduci l animazione completa dopo aver modificato un fotogramma per confermare la continuità del movimento.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Utilizza la scheda di contatto per la revisione con il team',
+    },
+    {
+      type: 'paragraph',
+      html: 'La scheda di contatto PNG mostra tutti i fotogrammi e i loro livelli di colore su un unica immagine, ideale per la collaborazione tra artisti e programmatori.',
+    },
+  ],
+  faq,
+  bibliographyTitle: 'Riferimenti per lo sviluppo delle collisioni',
+  bibliography: bibliographyEntries,
+  howTo,
+  schemas: [softwareApplication, faqPage, howToSchema],
+};