@jjlmoya/utils-games-development 1.51.0 → 1.52.0

package/src/tool/saveFileEditor/game-save-file-editor.css

@@ -0,0 +1,250 @@
+.save-editor-main-card {
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+  padding: 1.5rem;
+  border-radius: 1rem;
+  background: var(--bg-surface, #fff);
+  border: 1px solid var(--border-base, #e2e8f0);
+  box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.05);
+  color: var(--text-base, #0f172a);
+  transition: background-color 0.2s, border-color 0.2s;
+}
+
+.theme-dark .save-editor-main-card,
+:global(.theme-dark) .save-editor-main-card {
+  background: var(--bg-surface, #0f172a);
+  border-color: var(--border-base, #1e293b);
+  color: var(--text-base, #f8fafc);
+}
+
+.editor-unified-layout {
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: 1.5rem;
+}
+
+@media (min-width: 900px) {
+  .editor-unified-layout {
+    grid-template-columns: 1fr 1fr;
+  }
+}
+
+.control-panel {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+
+.dropzone {
+  border: 2px dashed var(--border-base, #cbd5e1);
+  border-radius: 0.75rem;
+  padding: 2rem 1rem;
+  text-align: center;
+  background: rgba(59, 130, 246, 0.03);
+  cursor: pointer;
+  transition: background-color 0.2s;
+}
+
+.theme-dark .dropzone,
+:global(.theme-dark) .dropzone {
+  border-color: var(--border-base, #334155);
+  background: rgba(30, 41, 59, 0.3);
+}
+
+.dropzone:hover {
+  background: rgba(59, 130, 246, 0.08);
+}
+
+.panel-section-title {
+  font-size: 1rem;
+  font-weight: 700;
+  margin: 0 0 0.25rem;
+  color: var(--text-base, #0f172a);
+  opacity: 0.9;
+}
+
+.theme-dark .panel-section-title,
+:global(.theme-dark) .panel-section-title {
+  color: var(--text-base, #f8fafc);
+}
+
+.options-row {
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: 0.75rem;
+}
+
+@media (min-width: 500px) {
+  .options-row {
+    grid-template-columns: 1fr 1fr;
+  }
+}
+
+.form-group {
+  display: flex;
+  flex-direction: column;
+  gap: 0.35rem;
+}
+
+.form-label {
+  font-size: 0.8125rem;
+  font-weight: 600;
+}
+
+.input-select, .input-text, .textarea-code {
+  width: 100%;
+  padding: 0.6rem 0.8rem;
+  border-radius: 0.5rem;
+  border: 1px solid var(--border-base, #cbd5e1);
+  background: var(--bg-surface, #fff);
+  color: var(--text-base, #0f172a);
+  font-size: 0.875rem;
+}
+
+.method-chip-group {
+  display: flex;
+  gap: 0.35rem;
+  background: var(--bg-surface, #fff);
+  padding: 0.25rem;
+  border-radius: 0.5rem;
+  border: 1px solid var(--border-base, #cbd5e1);
+}
+
+.theme-dark .method-chip-group,
+:global(.theme-dark) .method-chip-group {
+  background: var(--bg-surface, #0f172a);
+  border-color: var(--border-base, #334155);
+}
+
+.chip-btn {
+  flex: 1;
+  padding: 0.45rem 0.5rem;
+  border-radius: 0.375rem;
+  border: none;
+  background: transparent;
+  color: var(--text-base, #64748b);
+  font-size: 0.75rem;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.15s ease;
+  text-align: center;
+  white-space: nowrap;
+}
+
+.theme-dark .chip-btn,
+:global(.theme-dark) .chip-btn {
+  color: var(--text-base, #94a3b8);
+}
+
+.chip-btn.active {
+  background: var(--accent-base, #3b82f6);
+  color: var(--text-inverse, #fff);
+  box-shadow: 0 2px 6px rgba(59, 130, 246, 0.3);
+}
+
+.chip-btn:hover:not(.active) {
+  background: rgba(59, 130, 246, 0.08);
+  color: var(--accent-base, #3b82f6);
+}
+
+.textarea-code {
+  min-height: 250px;
+  resize: vertical;
+}
+
+.btn-primary {
+  padding: 0.75rem 1.25rem;
+  border-radius: 0.5rem;
+  border: none;
+  background: var(--accent-base, #3b82f6);
+  color: var(--text-inverse, #fff);
+  font-weight: 700;
+  cursor: pointer;
+  transition: all 0.2s;
+}
+
+.btn-primary:hover {
+  background: var(--accent-base, #2563eb);
+}
+
+.btn-secondary {
+  padding: 0.5rem 1rem;
+  border-radius: 0.5rem;
+  border: 1px solid var(--border-base, #cbd5e1);
+  background: transparent;
+  color: inherit;
+  font-weight: 600;
+  font-size: 0.875rem;
+  cursor: pointer;
+}
+
+.theme-dark .btn-secondary,
+:global(.theme-dark) .btn-secondary {
+  border-color: var(--border-base, #334155);
+  color: var(--text-base, #e2e8f0);
+}
+
+.error-banner {
+  padding: 0.75rem 1rem;
+  border-radius: 0.5rem;
+  background: rgba(239, 68, 68, 0.1);
+  border: 1px solid rgba(239, 68, 68, 0.3);
+  color: var(--text-danger, #ef4444);
+  font-size: 0.875rem;
+}
+
+.stats-grid {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  gap: 0.75rem;
+  padding: 1rem;
+  border-radius: 0.75rem;
+  background: rgba(0, 0, 0, 0.02);
+}
+
+.theme-dark .stats-grid,
+:global(.theme-dark) .stats-grid {
+  background: rgba(255, 255, 255, 0.02);
+}
+
+.stat-item {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  text-align: center;
+}
+
+.stat-val {
+  font-size: 1.125rem;
+  font-weight: 800;
+  color: var(--accent-base, #3b82f6);
+}
+
+.stat-lbl {
+  font-size: 0.75rem;
+  opacity: 0.7;
+}
+
+.copied-notice {
+  color: var(--accent-base, #10b981);
+  font-size: 0.875rem;
+}
+
+.tree-view-container {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+
+.tree-toolbar {
+  display: flex;
+  gap: 0.5rem;
+  flex-wrap: wrap;
+}
+
+.tree-node {
+  margin-left: 1rem;
+  padding-left: 0.5rem;
+  border-left: 1px dashed var(--border-subtle, #cbd5e1);
+}

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

@@ -0,0 +1,182 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { SaveFileEditorUI } from '../ui';
+import { bibliographyEntries } from '../bibliography';
+
+export const content: ToolLocaleContent<SaveFileEditorUI> = {
+  slug: 'spiel-speicherstand-editor',
+  title: 'Spiel Speicherstand Editor und Obfuskator',
+  description: 'Entschlüsseln, überprüfen, bearbeiten Sie JSON Payloads und verschlüsseln Sie Spiel Speicherstände lokal mit Base64, XOR Maskierung oder Klartext.',
+  ui: {
+    title: 'Spiel Speicherstand Editor & Obfuskator',
+    subtitle: 'Lokale Speicherstände sicher prüfen, bearbeiten und verschlüsseln ohne Serverübertragung',
+    dropSaveFile: 'Ziehen Sie die Speicherdatei hierher oder klicken Sie',
+    orSelectFile: 'oder klicken Sie, um eine lokale Datei auszuwählen',
+    encryptionMethod: 'Verschlüsselungsformat',
+    methodBase64: 'Base64 Kodierung',
+    methodXor: 'XOR Maske + Base64',
+    methodRaw: 'Unverschlüsseltes JSON',
+    xorKeyLabel: 'Geheimer XOR Schlüssel',
+    xorKeyPlaceholder: 'z.B. MeinGeheimerSchluessel2026',
+    jsonRawTitle: 'Entschlüsseltes JSON Payload (Live Editor)',
+    encodeAndDownload: 'Verschlüsseln & Datei Herunterladen',
+    copyEncoded: 'Verschlüsselten Text Kopieren',
+    copiedNotice: 'In die Zwischenablage kopiert!',
+    decodedKeysCount: 'Gesamte Parameter',
+    dataSize: 'Payload Größe',
+    detectedFormat: 'Erkanntes Format',
+    exportPreviewLabel: 'Vorschau der Verschlüsselten Ausgabe',
+    decodePanelTitle: 'Entschlüsselung und Live JSON Editor',
+    exportPanelTitle: 'Neu Verschlüsselte Ausgabe',
+    decodeError: 'Fehler beim Entschlüsseln der Speicherdatei',
+    bytesUnit: 'B',
+  },
+  seo: [
+    {
+      type: 'title',
+      level: 2,
+      text: 'Sicherheit und Obfuskationsprotokolle für Spielspeicherstände',
+    },
+    {
+      type: 'paragraph',
+      html: 'Videospiele serialisieren den Fortschritt des Spielers in persistenten Speicherformaten, um Inventarbestände, freigeschaltete Level und Spielerattribute über Spielsitzungen hinweg zu bewahren. Um einfaches Ändern im Texteditor durch Endnutzer zu verhindern, obfuszieren Entwickler Speicherstände mit Kodierungsschemata wie Base64 oder XOR Bitmaskierung mit einem geheimen Schlüssel. Während der Qualitätssicherung und des Live Operations Debuggings benötigen Entwicklungsteams sofortigen Zugriff auf rohe JSON Strukturen, um Grenzwerttests durchzuführen und modifizierte Daten ohne erneutes Kompilieren von Spielbinärdateien bereitzustellen.',
+    },
+    {
+      type: 'stats',
+      columns: 4,
+      items: [
+        { label: 'Client Verarbeitung', value: '100% Lokal' },
+        { label: 'Unterstützte Dekoder', value: 'Base64 / XOR / JSON' },
+        { label: 'Dekodierungslatenz', value: '0 ms' },
+        { label: 'Datenverlust Risiko', value: 'Null' },
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Vergleich der Obfuskationsverfahren',
+    },
+    {
+      type: 'comparative',
+      columns: 3,
+      items: [
+        {
+          title: 'Base64 Kodierung',
+          description: 'Schnelle Zeichenkonvertierung gegen einfaches Bearbeiten im Texteditor ohne kryptografische Sicherheit.',
+        },
+        {
+          title: 'XOR Maskierung + Base64',
+          description: 'Standard in der Indie Spieleentwicklung. Mischt String Bytes mit einem Schlüssel gegen Cheat Engines.',
+        },
+        {
+          title: 'Unverschlüsseltes JSON',
+          description: 'Lesbarer Speicherstand für Prototypen und interne Team Iterationen.',
+        },
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'QS Testpraxis für Speicherstandsüberprüfung',
+    },
+    {
+      type: 'tip',
+      title: 'Best Practices für Speicherstandssicherheit in der QS',
+      html: 'Verwenden Sie getrennte Debug Schlüssel für interne Builds. Nutzen Sie lokale Inspektoren zur Überprüfung von Grenzwerten ohne Neukompilierung des Spielcodes.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Richtlinien für Spielzustandsparameter',
+    },
+    {
+      type: 'table',
+      headers: ['Datentyp', 'Empfohlenes Format', 'Typischer Anwendungsfall', 'Obfuskationsschicht'],
+      rows: [
+        ['Numerische Zahlen', '32-Bit-Integer', 'Münzen, Level, XP, Munition', 'XOR-maskiert'],
+        ['Booleche Flags', 'Standard-Boolean', 'Tutorial Abgeschlossen', 'Base64 / XOR'],
+        ['Verschachtelte Objekte', 'JSON-Hierarchie', 'Inventar, Fähigkeiten', 'Base64-kodiert'],
+        ['Zeitstempel', 'ISO 8601 UTC', 'Tägliches Login', 'XOR-maskiert'],
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Reverse Engineering und Anti Tamper Überlegungen',
+    },
+    {
+      type: 'paragraph',
+      html: 'Obfuskation auf Client Seite verhindert einfaches Ändern durch Gelegenheitsspieler, jedoch sind XOR und Base64 keine echten kryptografischen Algorithmen. Werkzeuge zur Speicheranalyse wie RenderDoc oder x64dbg können Schlüsselgenerierungsroutinen direkt in kompilierten C++ oder C# Baugruppen untersuchen. Für kompetitive Titel sind serverseitige Validierungen oder kryptografische HMAC Signaturen unerlässlich.',
+    },
+  ],
+  faqTitle: 'Häufig Gestellte Fragen',
+  faq: [
+    {
+      question: 'Werden meine Speicherdaten auf einen Server hochgeladen?',
+      answer: 'Nein. Alle Vorgänge finden zu 100% lokal in Ihrem Browser statt.',
+    },
+    {
+      question: 'Wie funktioniert die XOR Obfuskation in Unity oder Godot?',
+      answer: 'Die XOR Obfuskation wendet bitweise XOR Operationen auf UTF-8 Bytes gegen einen geheimen Schlüssel an.',
+    },
+  ],
+  howTo: [
+    {
+      name: 'Datei Laden oder Einfügen',
+      text: 'Laden Sie Ihre verschlüsselte Speicherdatei hoch.',
+    },
+    {
+      name: 'Methode und Schlüssel Wählen',
+      text: 'Wählen Sie Base64 oder XOR und geben Sie den Schlüssel ein.',
+    },
+    {
+      name: 'JSON Bearbeiten',
+      text: 'Ändern Sie die Werte direkt im Live Editor.',
+    },
+    {
+      name: 'Verschlüsseln und Exportieren',
+      text: 'Laden Sie die neue Datei für Tests herunter.',
+    },
+  ],
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: 'Spiel Speicherstand Editor',
+      applicationCategory: 'DeveloperApplication',
+      operatingSystem: 'Any',
+      offers: {
+        '@type': 'Offer',
+        price: '0',
+        priceCurrency: 'EUR',
+      },
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: [
+        {
+          '@type': 'Question',
+          name: 'Werden meine Speicherdaten hochgeladen?',
+          acceptedAnswer: {
+            '@type': 'Answer',
+            text: 'Nein. Alle Vorgänge finden zu 100% lokal statt.',
+          },
+        },
+      ],
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: 'So bearbeiten Sie Speicherstände',
+      step: [
+        {
+          '@type': 'HowToStep',
+          name: 'Datei Laden',
+          text: 'Laden Sie Ihre Speicherdatei hoch.',
+        },
+      ],
+    },
+  ],
+  bibliographyTitle: 'Referenzen und Weiterführende Literatur',
+  bibliography: bibliographyEntries,
+};

package/src/tool/saveFileEditor/i18n/en.ts

@@ -0,0 +1,182 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { SaveFileEditorUI } from '../ui';
+import { bibliographyEntries } from '../bibliography';
+
+export const content: ToolLocaleContent<SaveFileEditorUI> = {
+  slug: 'game-save-file-editor',
+  title: 'Game Save File Obfuscator and Editor',
+  description: 'Decrypt, inspect, edit JSON payloads, and re-encrypt game save files using Base64, XOR masking, or plain text 100% locally in your browser.',
+  ui: {
+    title: 'Game Save File Obfuscator & Editor',
+    subtitle: 'Inspect, modify, and encrypt local save state files securely without server leaks',
+    dropSaveFile: 'Drag & Drop game save file here',
+    orSelectFile: 'or click to browse local file',
+    encryptionMethod: 'Encryption Format',
+    methodBase64: 'Base64 Encoding',
+    methodXor: 'XOR Mask + Base64',
+    methodRaw: 'Plain JSON / Unencrypted',
+    xorKeyLabel: 'XOR Secret Key',
+    xorKeyPlaceholder: 'e.g. MySecretGameKey2026',
+    jsonRawTitle: 'Decoded JSON Payload (Live Editor)',
+    encodeAndDownload: 'Encrypt & Download Save File',
+    copyEncoded: 'Copy Encrypted Text',
+    copiedNotice: 'Copied to Clipboard!',
+    decodedKeysCount: 'Total Parameters',
+    dataSize: 'Payload Size',
+    detectedFormat: 'Detected Format',
+    exportPreviewLabel: 'Encrypted Output Preview',
+    decodePanelTitle: 'Decode and Live JSON Editor',
+    exportPanelTitle: 'Re Encrypted Output Payload',
+    decodeError: 'Failed to decode save file',
+    bytesUnit: 'B',
+  },
+  seo: [
+    {
+      type: 'title',
+      level: 2,
+      text: 'Game Save File Security and Obfuscation Protocols',
+    },
+    {
+      type: 'paragraph',
+      html: 'Video games routinely serialize player progression state into persistent storage formats to maintain inventory counts, unlocked stages, player attributes, and narrative flags across play sessions. To prevent trivial end-user tampering via plain text editors, game studios obfuscate save states using binary encoding schemes like Base64 or bitwise XOR masking against a secret string key. During internal QA testing and live operations debugging, development teams require immediate capability to inspect raw JSON structures, force boundary test states, and re-encrypt modified payloads for deployment without recompiling game binaries.',
+    },
+    {
+      type: 'stats',
+      columns: 4,
+      items: [
+        { label: 'Client Processing Privacy', value: '100%' },
+        { label: 'Supported Decoders', value: 'Base64 / XOR / JSON' },
+        { label: 'Latency', value: '0 ms' },
+        { label: 'Data Leak Risk', value: 'Zero' },
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Obfuscation Schemes Comparison',
+    },
+    {
+      type: 'comparative',
+      columns: 3,
+      items: [
+        {
+          title: 'Base64 Encoding',
+          description: 'Fast, lightweight string conversion that prevents casual end-user text edits in plain notepad but offers no cryptographic security.',
+        },
+        {
+          title: 'XOR Masking + Base64',
+          description: 'Standard practice in indie game development. Blends string bytes with a custom secret key to prevent casual memory editing or cheat engines.',
+        },
+        {
+          title: 'Plain JSON Payload',
+          description: 'Unencrypted readable save state. Ideal for initial prototyping, debug builds, and rapid internal team iterations.',
+        },
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'QA Testing Practices for Save State Verification',
+    },
+    {
+      type: 'tip',
+      title: 'Best Practices for Game Save Security during QA',
+      html: 'Always maintain separate debug keys for internal builds and production builds. When verifying edge-case bugs, use local tree inspectors to force inventory caps, boundary levels, and edge stats without recompiling game code.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Game State Parameter Guidelines Table',
+    },
+    {
+      type: 'table',
+      headers: ['Data Type', 'Recommended Format', 'Common Use Case', 'Obfuscation Layer'],
+      rows: [
+        ['Numeric Integers', '32-bit Integer', 'Coins, Level, XP, Ammo', 'XOR Masked'],
+        ['Boolean Flags', 'Standard Boolean', 'Tutorial Complete, Boss Defeated', 'Base64 / XOR'],
+        ['Nested Objects', 'JSON Hierarchy', 'Player Inventory, Skill Tree', 'Base64 Encoded'],
+        ['Timestamp Strings', 'ISO 8601 UTC', 'Daily Login, Save Timestamp', 'XOR Masked'],
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Reverse Engineering and Anti Tamper Considerations',
+    },
+    {
+      type: 'paragraph',
+      html: 'While client-side obfuscation prevents casual players from modifying save files in standard text editors, XOR masking and Base64 encoding are not cryptographic algorithms. Memory scanners, cheat software, and reverse-engineering tools like RenderDoc or x64dbg can inspect key generation routines directly within compiled C++ or C# game assemblies. For competitive multiplayer titles, authoritative server validation or cryptographic HMAC signatures (such as SHA-256 integrity hashes appended to the save file payload) are essential to detect payload tampering upon game startup.',
+    },
+  ],
+  faqTitle: 'Frequently Asked Questions',
+  faq: [
+    {
+      question: 'Are my game save files uploaded to a remote server?',
+      answer: 'No. All decoding, JSON tree rendering, editing, and re-encoding happen 100% inside your web browser web workers and JavaScript engine.',
+    },
+    {
+      question: 'How does XOR key obfuscation work in game engines like Unity or Godot?',
+      answer: 'XOR obfuscation iterates over UTF-8 bytes of the serialized JSON string, applying a bitwise XOR operation against characters of a secret key, then encoding the resulting bytes in Base64.',
+    },
+  ],
+  howTo: [
+    {
+      name: 'Load or Paste Save File',
+      text: 'Upload your encrypted save file or select one of the built-in game presets (RPG, Platformer, Tycoon).',
+    },
+    {
+      name: 'Select Decoding Method and Key',
+      text: 'Choose Base64 or XOR Masking and enter the corresponding game secret key, then click Decode.',
+    },
+    {
+      name: 'Edit JSON State',
+      text: 'Use the interactive tree view or raw code tab to adjust levels, gold, inventory items, or game flags.',
+    },
+    {
+      name: 'Encrypt and Export',
+      text: 'Select your target output format and download your modified save file ready for game testing.',
+    },
+  ],
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: 'Game Save File Obfuscator and Editor',
+      applicationCategory: 'DeveloperApplication',
+      operatingSystem: 'Any',
+      offers: {
+        '@type': 'Offer',
+        price: '0',
+        priceCurrency: 'USD',
+      },
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: [
+        {
+          '@type': 'Question',
+          name: 'Are my game save files uploaded to a remote server?',
+          acceptedAnswer: {
+            '@type': 'Answer',
+            text: 'No. All decoding and editing happen 100% inside your browser.',
+          },
+        },
+      ],
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: 'How to Edit Encrypted Game Save Files',
+      step: [
+        {
+          '@type': 'HowToStep',
+          name: 'Load or Paste Save File',
+          text: 'Upload your encrypted save file.',
+        },
+      ],
+    },
+  ],
+  bibliographyTitle: 'References and Further Reading',
+  bibliography: bibliographyEntries,
+};